/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

#include <boost/bind.hpp>

#include <boost/algorithm/string.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <boost/archive/text_oarchive.hpp>

#include <boost/archive/text_iarchive.hpp>

#include <boost/serialization/vector.hpp>

#include <boost/serialization/map.hpp>

#include <boost/serialization/string.hpp>

#include <boost/serialization/split_free.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Presence/PresenceSender.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/MUC/MUCManager.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/Elements/DeliveryReceipt.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/VCards/VCardManager.h>

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

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

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

inviteJIDs.push_back(pair.second);

}

uiEventStream_->send(boost::make_shared<CreateImpromptuMUCUIEvent>(inviteJIDs, chat.jid, ""));

}

else if (chat.isMUC) {

/* FIXME: This means that recents requiring passwords will just flat-out not work */

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

}

else {

uiEventStream_->send(boost::make_shared<RequestChatUIEvent>(chat.jid));

}

}

void ChatsManager::handleLocalServiceFound(const JID& service, boost::shared_ptr<DiscoInfo> info) {

foreach (DiscoInfo::Identity identity, info->getIdentities()) {

if ((identity.getCategory() == "directory"

&& identity.getType() == "chatroom")

|| (identity.getCategory() == "conference"

&& identity.getType() == "text")) {

localMUCServiceJID_ = service;

localMUCServiceFinderWalker_->endWalk();

SWIFT_LOG(debug) << "Use following MUC service for impromptu chats: " << localMUCServiceJID_ << std::endl;

break;

}

}

}

void ChatsManager::handleLocalServiceWalkFinished() {

onImpromptuMUCServiceDiscovered(!localMUCServiceJID_.toString().empty());

}

std::vector<ChatListWindow::Chat> ChatsManager::getRecentChats() const {

return std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());

}

foreach (ChatListWindow::Chat chat, recentChats_) {

if (!chat.isMUC) {

}

}

return result;

}

ChatsManager::SingleChatWindowFactoryAdapter::SingleChatWindowFactoryAdapter(ChatWindow* chatWindow) : chatWindow_(chatWindow) {}

ChatsManager::SingleChatWindowFactoryAdapter::~SingleChatWindowFactoryAdapter() {}

ChatWindow* ChatsManager::SingleChatWindowFactoryAdapter::createChatWindow(const JID &, UIEventStream*) {

return chatWindow_;

}

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <map>

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUCRegistry.h>

#include <Swiften/MUC/MUCBookmark.h>

#include <Swiften/MUC/MUC.h>

#include <Swift/Controllers/ContactProvider.h>

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

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

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

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

namespace Swift {

class EventController;

class ChatController;

class ChatControllerBase;

class MUCController;

class MUCManager;

class JoinMUCWindow;

class AvatarManager;

class StanzaChannel;

class IQRouter;

class PresenceSender;

class MUCBookmarkManager;

class ChatListWindowFactory;

class TimerFactory;

class EntityCapsProvider;

class DirectedPresenceSender;

class MUCSearchWindowFactory;

class ProfileSettingsProvider;

class MUCSearchController;

class FileTransferOverview;

class FileTransferController;

class XMPPRoster;

class SettingsProvider;

class WhiteboardManager;

class HistoryController;

class HighlightManager;

class ClientBlockListManager;

class ChatMessageParser;

class DiscoServiceWalker;

class AutoAcceptMUCInviteDecider;

class UserSearchController;

class VCardManager;

class ChatsManager : public ContactProvider {

public:

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, UserSearchController* inviteUserSearchController, VCardManager* vcardManager);

virtual ~ChatsManager();

void setAvatarManager(AvatarManager* avatarManager);

void setOnline(bool enabled);

void setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info);

void handleIncomingMessage(boost::shared_ptr<Message> message);

std::vector<ChatListWindow::Chat> getRecentChats() const;

boost::signal<void (bool supportsImpromptu)> onImpromptuMUCServiceDiscovered;

private:

class SingleChatWindowFactoryAdapter : public ChatWindowFactory {

public:

SingleChatWindowFactoryAdapter(ChatWindow* chatWindow);

virtual ~SingleChatWindowFactoryAdapter();

virtual ChatWindow* createChatWindow(const JID &, UIEventStream*);

private:

ChatWindow* chatWindow_;

};

private:

ChatListWindow::Chat createChatListChatItem(const JID& jid, const std::string& activity);

void handleChatRequest(const std::string& contact);

void finalizeImpromptuJoin(MUC::ref muc, const std::vector<JID>& jidsToInvite, const std::string& reason, const boost::optional<JID>& reuseChatJID = boost::optional<JID>());

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

void handleSearchMUCRequest();

void handleMUCSelectedAfterSearch(const JID&);

void rebindControllerJID(const JID& from, const JID& to);

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

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

void handleMUCBookmarkAdded(const MUCBookmark& bookmark);

void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);

void handleUserLeftMUC(MUCController* mucController);

void handleBookmarksReady();

void handleChatActivity(const JID& jid, const std::string& activity, bool isMUC);

void handleNewFileTransferController(FileTransferController*);

void handleWhiteboardSessionRequest(const JID& contact, bool senderIsSelf);

void handleWhiteboardStateChange(const JID& contact, const ChatWindow::WhiteboardSessionState state);

boost::optional<ChatListWindow::Chat> removeExistingChat(const ChatListWindow::Chat& chat);

void appendRecent(const ChatListWindow::Chat& chat);

void prependRecent(const ChatListWindow::Chat& chat);

}

window_->setResults(results);

}

}

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

suggestionsJID_= jid;

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

if (vcard) {

handleVCardChanged(jid, vcard);

}

}

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

window_->setContactSuggestions(contactSuggester_->getSuggestions(text));

}

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

}

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

if (window_) {

foreach(const JID& jid, jids) {

updates.push_back(convertJIDtoContact(jid));

}

window_->updateContacts(updates);

}

}

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

foreach(const JID& jid, jids) {

contacts.push_back(convertJIDtoContact(jid));

}

window_->addContacts(contacts);

}

// name lookup

boost::optional<XMPPRosterItem> rosterItem = rosterController_->getItem(jid);

if (rosterItem && !rosterItem->getName().empty()) {

} else {

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

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

} else {

}

}

// presence lookup

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

if (presence) {

} else {

}

// avatar lookup

return contact;

}

void UserSearchController::handleDiscoWalkFinished() {

window_->setServerSupportsSearch(false);

endDiscoWalker();

}

void UserSearchController::initializeUserWindow() {

if (!window_) {

UserSearchWindow::Type windowType = UserSearchWindow::AddContact;

switch(type_) {

case AddContact:

windowType = UserSearchWindow::AddContact;

break;

case StartChat:

windowType = UserSearchWindow::ChatToContact;

break;

case InviteToChat:

windowType = UserSearchWindow::InviteToChat;

break;

}

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

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_->setSelectedService(JID(jid_.getDomain()));

window_->clear();

}

}

/*

* Copyright (c) 2010-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <map>

#include <vector>

#include <string>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/Presence.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 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:

enum Type {AddContact, StartChat, InviteToChat};

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

~UserSearchController();

UserSearchWindow* getUserSearchWindow();

void setCanInitiateImpromptuMUC(bool supportsImpromptu);

private:

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

void handleFormRequested(const JID& service);

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

void handleDiscoWalkFinished();

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

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

void handleSearchResponse(boost::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 endDiscoWalker();

void initializeUserWindow();

private:

Type type_;

JID jid_;

JID suggestionsJID_;

UIEventStream* uiEventStream_;

VCardManager* vcardManager_;

UserSearchWindowFactory* factory_;

IQRouter* iqRouter_;

RosterController* rosterController_;

UserSearchWindow* window_;

DiscoServiceWalker* discoWalker_;

ContactSuggester* contactSuggester_;

AvatarManager* avatarManager_;

PresenceOracle* presenceOracle_;

};

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

#pragma once

#include <boost/filesystem/path.hpp>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/JID/JID.h>

namespace Swift {

public:

Contact();

Contact(const std::string& name, const JID& jid, StatusShow::Type statusType, const boost::filesystem::path& path);

public:

std::string name;

JID jid;

StatusShow::Type statusType;

boost::filesystem::path avatarPath;

};

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

#pragma once

#include <vector>

#include <Swift/Controllers/Contact.h>

namespace Swift {

class ContactProvider {

public:

virtual ~ContactProvider();

};

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

#include <Swift/Controllers/ContactSuggester.h>

#include <boost/algorithm/string/find.hpp>

#include <boost/lambda/lambda.hpp>

#include <boost/lambda/bind.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/ContactProvider.h>

#include <algorithm>

#include <vector>

#include <set>

namespace lambda = boost::lambda;

namespace Swift {

ContactSuggester::ContactSuggester() {

}

ContactSuggester::~ContactSuggester() {

}

void ContactSuggester::addContactProvider(ContactProvider* provider) {

contactProviders_.push_back(provider);

}

}

foreach(ContactProvider* provider, contactProviders_) {

append(results, provider->getContacts());

}

results.erase(std::remove_if(results.begin(), results.end(), !lambda::bind(&ContactSuggester::matchContact, search, lambda::_1)),

results.end());

return results;

}

bool ContactSuggester::fuzzyMatch(std::string text, std::string match) {

for (std::string::iterator currentQueryChar = match.begin(); currentQueryChar != match.end(); currentQueryChar++) {

//size_t result = text.find(*currentQueryChar);

std::string::iterator result = boost::algorithm::ifind_first(text, std::string(currentQueryChar, currentQueryChar+1)).begin();

if (result == text.end()) {

return false;

}

text.erase(result);

}

return true;

}

} else {

}

}

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

#pragma once

#include <string>

#include <vector>

#include <Swift/Controllers/Contact.h>

namespace Swift {

class ContactProvider;

class ContactSuggester {

public:

ContactSuggester();

~ContactSuggester();

void addContactProvider(ContactProvider* provider);

private:

/**

* Performs fuzzy matching on the string text. Matches when each character of match string is present in sequence in text string.

*/

static bool fuzzyMatch(std::string text, std::string match);

private:

std::vector<ContactProvider*> contactProviders_;

};

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

#include <Swift/Controllers/ContactsFromXMPPRoster.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterItem.h>

namespace Swift {

ContactsFromXMPPRoster::ContactsFromXMPPRoster(XMPPRoster* roster, AvatarManager* avatarManager, PresenceOracle* presenceOracle) : roster_(roster), avatarManager_(avatarManager), presenceOracle_(presenceOracle) {

}

ContactsFromXMPPRoster::~ContactsFromXMPPRoster() {

}

std::vector<XMPPRosterItem> rosterItems = roster_->getItems();

foreach(const XMPPRosterItem& rosterItem, rosterItems) {

results.push_back(contact);

}

return results;

}

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

#pragma once

#include <Swift/Controllers/ContactProvider.h>

namespace Swift {

class PresenceOracle;

class AvatarManager;

class XMPPRoster;

class ContactsFromXMPPRoster : public ContactProvider {

public:

ContactsFromXMPPRoster(XMPPRoster* roster, AvatarManager* avatarManager, PresenceOracle* presenceOracle);

virtual ~ContactsFromXMPPRoster();

private:

XMPPRoster* roster_;

AvatarManager* avatarManager_;

PresenceOracle* presenceOracle_;

};

}

/*

* Copyright (c) 2010-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <vector>

#include <string>

#include <Swiften/JID/JID.h>

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

#include <Swift/Controllers/Contact.h>

namespace Swift {

class UserSearchWindow {

public:

enum Type {AddContact, ChatToContact, InviteToChat};

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(boost::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 setJIDs(const std::vector<JID>&) = 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 show() = 0;

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

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

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

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

boost::signal<void (const std::vector<JID>&)> onJIDUpdateRequested;

boost::signal<void (const std::vector<JID>&)> onJIDAddRequested;

};

}