#!/usr/bin/env bash

set -e

if [ -z "$1" ]; then

echo "Please specify the location of the boost source tree"

exit -1

fi

TARGET_DIR=src

if [ ! -d "$TARGET_DIR" ]; then

mkdir $TARGET_DIR

fi

./bcp --boost="$1" \

tools/bcp \

algorithm/string.hpp \

archive/text_iarchive.hpp \

archive/text_oarchive.hpp \

asio.hpp \

assign/list_of.hpp \

bind.hpp \

cast.hpp \

date_time/posix_time/posix_time.hpp \

date_time/posix_time/time_serialize.hpp \

date_time/local_time/local_time.hpp \

date_time/c_local_time_adjustor.hpp \

date_time/gregorian/gregorian_types.hpp \

filesystem.hpp \

filesystem/fstream.hpp \

format.hpp \

lambda/lambda.hpp \

lambda/bind.hpp \

logic/tribool.hpp \

noncopyable.hpp \

numeric/conversion/cast.hpp \

optional.hpp \

program_options.hpp \

random/mersenne_twister.hpp \

random/variate_generator.hpp \

random/uniform_int.hpp \

regex.hpp \

scope_exit.hpp \

serialization/serialization.hpp \

serialization/vector.hpp \

serialization/list.hpp \

serialization/map.hpp \

serialization/shared_ptr.hpp \

serialization/string.hpp \

serialization/set.hpp \

serialization/version.hpp \

serialization/split_member.hpp \

serialization/optional.hpp \

signals2.hpp \

thread.hpp \

unordered_map.hpp \

uuid/uuid.hpp \

uuid/uuid_io.hpp \

uuid/uuid_generators.hpp \

variant.hpp \

spirit/include/lex_lexertl.hpp \

typeof/incr_registration_group.hpp \

atomic \

system/src/error_code.cpp \

phoenix/support/detail/iterate.hpp \

type_traits.hpp \

$TARGET_DIR

cp $1/LICENSE_1_0.txt $TARGET_DIR

rm -rf $TARGET_DIR/libs/config

rm -rf $TARGET_DIR/libs/smart_ptr

LIBS="date_time regex system thread signals2 filesystem program_options serialization archive atomic"

for lib in $LIBS; do

rm -rf $TARGET_DIR/libs/$lib/build $TARGET_DIR/libs/$lib/*.doc $TARGET_DIR/libs/$lib/src/*.doc $TARGET_DIR/libs/$lib/src/CMakeLists.txt $TARGET_DIR/libs/$lib/test

done

rm -rf $TARGET_DIR/tools/bcp/*.html $TARGET_DIR/libs/test $TARGET_DIR/doc $TARGET_DIR/boost.png $TARGET_DIR/boost/test $TARGET_DIR/tools/bcp/Jamfile.v2 $TARGET_DIR/tools/bcp/doc $TARGET_DIR/tools/bcp/test $TARGET_DIR/Jamroot

mv $TARGET_DIR/libs/filesystem/src/utf8_codecvt_facet.cpp $TARGET_DIR/libs/filesystem/src/filesystem_utf8_codecvt_facet.cpp

mv $TARGET_DIR/libs/program_options/src/utf8_codecvt_facet.cpp $TARGET_DIR/libs/program_options/src/program_options_utf8_codecvt_facet.cpp

for diff in *.diff; do

patch -p3 < $diff

done

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Slimber/LinkLocalPresenceManager.h>

#include <boost/bind.hpp>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/RosterPayload.h>

#include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>

namespace Swift {

LinkLocalPresenceManager::LinkLocalPresenceManager(LinkLocalServiceBrowser* browser) : browser(browser) {

browser->onServiceAdded.connect(

boost::bind(&LinkLocalPresenceManager::handleServiceAdded, this, _1));

browser->onServiceChanged.connect(

boost::bind(&LinkLocalPresenceManager::handleServiceChanged, this, _1));

browser->onServiceRemoved.connect(

boost::bind(&LinkLocalPresenceManager::handleServiceRemoved, this, _1));

}

boost::optional<LinkLocalService> LinkLocalPresenceManager::getServiceForJID(const JID& j) const {

if (service.getJID() == j) {

return service;

}

}

return boost::optional<LinkLocalService>();

}

void LinkLocalPresenceManager::handleServiceAdded(const LinkLocalService& service) {

std::shared_ptr<RosterPayload> roster(new RosterPayload());

roster->addItem(getRosterItem(service));

onRosterChanged(roster);

onPresenceChanged(getPresence(service));

}

void LinkLocalPresenceManager::handleServiceChanged(const LinkLocalService& service) {

onPresenceChanged(getPresence(service));

}

void LinkLocalPresenceManager::handleServiceRemoved(const LinkLocalService& service) {

std::shared_ptr<RosterPayload> roster(new RosterPayload());

roster->addItem(RosterItemPayload(service.getJID(), "", RosterItemPayload::Remove));

onRosterChanged(roster);

}

std::shared_ptr<RosterPayload> LinkLocalPresenceManager::getRoster() const {

std::shared_ptr<RosterPayload> roster(new RosterPayload());

roster->addItem(getRosterItem(service));

}

return roster;

}

std::vector<std::shared_ptr<Presence> > LinkLocalPresenceManager::getAllPresence() const {

std::vector<std::shared_ptr<Presence> > result;

result.push_back(getPresence(service));

}

return result;

}

RosterItemPayload LinkLocalPresenceManager::getRosterItem(const LinkLocalService& service) const {

}

std::string LinkLocalPresenceManager::getRosterName(const LinkLocalService& service) const {

LinkLocalServiceInfo info = service.getInfo();

if (!info.getNick().empty()) {

return info.getNick();

}

else if (!info.getFirstName().empty()) {

std::string result = info.getFirstName();

if (!info.getLastName().empty()) {

result += " " + info.getLastName();

}

return result;

}

else if (!info.getLastName().empty()) {

return info.getLastName();

}

return "";

}

std::shared_ptr<Presence> LinkLocalPresenceManager::getPresence(const LinkLocalService& service) const {

std::shared_ptr<Presence> presence(new Presence());

presence->setFrom(service.getJID());

switch (service.getInfo().getStatus()) {

case LinkLocalServiceInfo::Available:

presence->setShow(StatusShow::Online);

break;

case LinkLocalServiceInfo::Away:

presence->setShow(StatusShow::Away);

break;

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Slimber/MainController.h>

#include <boost/bind.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/LinkLocal/DNSSD/PlatformDNSSDQuerierFactory.h>

#include <Swiften/LinkLocal/LinkLocalService.h>

#include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>

#include <Slimber/FileVCardCollection.h>

#include <Slimber/Menulet.h>

#include <Slimber/MenuletController.h>

#include <Slimber/Server.h>

#include <SwifTools/Application/PlatformApplicationPathProvider.h>

using namespace Swift;

MainController::MainController(Menulet* menulet, EventLoop* eventLoop) {

dnsSDQuerier = PlatformDNSSDQuerierFactory(eventLoop).createQuerier();

assert(dnsSDQuerier);

linkLocalServiceBrowser = new LinkLocalServiceBrowser(dnsSDQuerier);

linkLocalServiceBrowser->onServiceAdded.connect(

boost::bind(&MainController::handleServicesChanged, this));

linkLocalServiceBrowser->onServiceRemoved.connect(

boost::bind(&MainController::handleServicesChanged, this));

linkLocalServiceBrowser->onServiceChanged.connect(

boost::bind(&MainController::handleServicesChanged, this));

vCardCollection = new FileVCardCollection(

PlatformApplicationPathProvider("Slimber").getDataDir());

server = new Server(5222, 5562, linkLocalServiceBrowser, vCardCollection, eventLoop);

server->onStopped.connect(

dnsSDQuerier->stop();

}

void MainController::start() {

dnsSDQuerier->start();

linkLocalServiceBrowser->start();

handleSelfConnected(false);

handleServicesChanged();

server->start();

}

void MainController::stop() {

server->stop();

linkLocalServiceBrowser->stop();

dnsSDQuerier->stop();

}

void MainController::handleSelfConnected(bool b) {

if (b) {

menuletController->setXMPPStatus("You are logged in", MenuletController::Online);

}

else {

menuletController->setXMPPStatus("You are not logged in", MenuletController::Offline);

}

}

void MainController::handleServicesChanged() {

std::vector<std::string> names;

std::string description = service.getDescription();

if (description != service.getName()) {

description += " (" + service.getName() + ")";

}

names.push_back(description);

}

menuletController->setUserNames(names);

}

void MainController::handleServerStopped(boost::optional<ServerError> error) {

if (error) {

std::string message;

switch (error->getType()) {

case ServerError::C2SPortConflict:

message = std::string("Error: Port ") + boost::lexical_cast<std::string>(server->getClientToServerPort()) + std::string(" in use");

break;

case ServerError::C2SError:

message = std::string("Local connection server error");

break;

case ServerError::LinkLocalPortConflict:

message = std::string("Error: Port ") + boost::lexical_cast<std::string>(server->getLinkLocalPort()) + std::string(" in use");

break;

case ServerError::LinkLocalError:

message = std::string("External connection server error");

break;

}

menuletController->setXMPPStatus(message, MenuletController::Offline);

}

else {

menuletController->setXMPPStatus("XMPP Server Not Running", MenuletController::Offline);

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Slimber/MenuletController.h>

#include <string>

#include <Slimber/Menulet.h>

MenuletController::MenuletController(Menulet* menulet) :

menulet(menulet), xmppStatus(Offline) {

menulet->onRestartClicked.connect(boost::ref(onRestartRequested));

update();

}

MenuletController::~MenuletController() {

}

void MenuletController::setXMPPStatus(const std::string& message, Status status) {

xmppStatus = status;

xmppStatusMessage = message;

update();

}

void MenuletController::setUserNames(const std::vector<std::string>& users) {

linkLocalUsers = users;

update();

}

void MenuletController::update() {

menulet->clear();

if (linkLocalUsers.empty()) {

menulet->setIcon("UsersOffline");

menulet->addItem("No online users");

}

else {

menulet->setIcon("UsersOnline");

menulet->addItem("Online users:");

menulet->addItem(std::string(" ") + user);

}

}

menulet->addSeparator();

menulet->addItem(xmppStatusMessage, (xmppStatus == Online ? "Online" : "Offline"));

menulet->addSeparator();

menulet->addAboutItem();

menulet->addSeparator();

menulet->addRestartItem();

menulet->addExitItem();

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Slimber/Server.h>

#include <string>

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/String.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/RosterPayload.h>

#include <Swiften/Elements/ToplevelElement.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/LinkLocal/IncomingLinkLocalSession.h>

#include <Swiften/LinkLocal/LinkLocalConnector.h>

#include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>

#include <Swiften/LinkLocal/LinkLocalServiceInfo.h>

#include <Swiften/LinkLocal/OutgoingLinkLocalSession.h>

#include <Swiften/Network/BoostConnection.h>

#include <Swiften/Network/BoostConnectionServer.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/ConnectionServer.h>

#include <Swiften/Session/Session.h>

#include <Swiften/Session/SessionTracer.h>

#include <Limber/Server/ServerFromClientSession.h>

#include <Limber/Server/UserRegistry.h>

#include <Slimber/LinkLocalPresenceManager.h>

#include <Slimber/VCardCollection.h>

namespace Swift {

Server::Server(

int clientConnectionPort,

int linkLocalConnectionPort,

LinkLocalServiceBrowser* linkLocalServiceBrowser,

VCardCollection* vCardCollection,

assert(!presenceManager);

presenceManager = new LinkLocalPresenceManager(linkLocalServiceBrowser);

presenceManager->onRosterChanged.connect(

boost::bind(&Server::handleRosterChanged, this, _1));

presenceManager->onPresenceChanged.connect(

boost::bind(&Server::handlePresenceChanged, this, _1));

serverFromClientConnectionServer->start();

serverFromNetworkConnectionServer->start();

}

void Server::stop() {

stop(boost::optional<ServerError>());

}

void Server::stop(boost::optional<ServerError> e) {

if (stopping) {

return;

}

stopping = true;

delete presenceManager;

presenceManager = nullptr;

if (serverFromClientSession) {

serverFromClientSession->finishSession();

}

serverFromClientSession.reset();

session->finishSession();

}

linkLocalSessions.clear();

connector->cancel();

}

connectors.clear();

tracers.clear();

if (serverFromNetworkConnectionServer) {

serverFromNetworkConnectionServer->stop();

connection.disconnect();

}

serverFromNetworkConnectionServerSignalConnections.clear();

serverFromNetworkConnectionServer.reset();

}

if (serverFromClientConnectionServer) {

serverFromClientConnectionServer->stop();

connection.disconnect();

}

serverFromClientConnectionServerSignalConnections.clear();

serverFromClientConnectionServer.reset();

}

stopping = false;

onStopped(e);

}

void Server::handleNewClientConnection(std::shared_ptr<Connection> connection) {

if (serverFromClientSession) {

connection->disconnect();

}

serverFromClientSession = std::shared_ptr<ServerFromClientSession>(

new ServerFromClientSession(idGenerator.generateID(), connection,

&payloadParserFactories, &payloadSerializers, &xmlParserFactory, &userRegistry));

serverFromClientSession->setAllowSASLEXTERNAL();

serverFromClientSession->onSessionStarted.connect(

boost::bind(&Server::handleSessionStarted, this));

serverFromClientSession->onElementReceived.connect(

boost::bind(&Server::handleElementReceived, this, _1,

serverFromClientSession));

serverFromClientSession->onSessionFinished.connect(

boost::bind(&Server::handleSessionFinished, this,

serverFromClientSession));

//tracers.push_back(std::shared_ptr<SessionTracer>(

// new SessionTracer(serverFromClientSession)));

serverFromClientSession->startSession();

}

stanza->setFrom(session->getRemoteJID());

if (!stanza->getTo().isValid()) {

stanza->setTo(session->getLocalJID());

}

if (std::shared_ptr<Presence> presence = std::dynamic_pointer_cast<Presence>(stanza)) {

if (presence->getType() == Presence::Available) {

if (!linkLocalServiceRegistered) {

linkLocalServiceRegistered = true;

linkLocalServiceBrowser->registerService(

session->getRemoteJID().toBare().toString(),

linkLocalConnectionPort, getLinkLocalServiceInfo(presence));

}

else {

linkLocalServiceBrowser->updateService(

getLinkLocalServiceInfo(presence));

}

lastPresence = presence;

}

else {

unregisterService();

}

}

else if (!stanza->getTo().isValid() || stanza->getTo() == session->getLocalJID() || stanza->getTo() == session->getRemoteJID().toBare()) {

if (std::shared_ptr<IQ> iq = std::dynamic_pointer_cast<IQ>(stanza)) {

if (iq->getPayload<RosterPayload>()) {

if (iq->getType() == IQ::Get) {

session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), presenceManager->getRoster()));

rosterRequested = true;

session->sendElement(presence);

}

}

else {

session->sendElement(IQ::createError(iq->getFrom(), iq->getID(), ErrorPayload::Forbidden, ErrorPayload::Cancel));

}

}

if (std::shared_ptr<VCard> vcard = iq->getPayload<VCard>()) {

if (iq->getType() == IQ::Get) {

session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), vCardCollection->getOwnVCard()));

}

else {

vCardCollection->setOwnVCard(vcard);

session->sendElement(IQ::createResult(iq->getFrom(), iq->getID()));

if (lastPresence) {

linkLocalServiceBrowser->updateService(getLinkLocalServiceInfo(lastPresence));

}

}

}

else {

session->sendElement(IQ::createError(iq->getFrom(), iq->getID(), ErrorPayload::FeatureNotImplemented, ErrorPayload::Cancel));

}

}

}

else {

JID toJID = stanza->getTo();

std::shared_ptr<Session> outgoingSession =

getLinkLocalSessionForJID(toJID);

if (outgoingSession) {

outgoingSession->sendElement(stanza);

}

void Server::handleLinkLocalSessionFinished(std::shared_ptr<Session> session) {

//std::cout << "Link local session from " << session->getRemoteJID() << " ended" << std::endl;

linkLocalSessions.erase(

std::remove(linkLocalSessions.begin(), linkLocalSessions.end(), session),

linkLocalSessions.end());

}

void Server::handleLinkLocalElementReceived(std::shared_ptr<ToplevelElement> element, std::shared_ptr<Session> session) {

if (std::shared_ptr<Stanza> stanza = std::dynamic_pointer_cast<Stanza>(element)) {

JID fromJID = session->getRemoteJID();

if (!presenceManager->getServiceForJID(fromJID.toBare())) {

return; // TODO: Send error back

}

stanza->setFrom(fromJID);

serverFromClientSession->sendElement(stanza);

}

}

void Server::handleConnectFinished(std::shared_ptr<LinkLocalConnector> connector, bool error) {

if (error) {

SWIFT_LOG(warning) << "Error connecting" << std::endl;

// TODO: Send back queued stanzas

}

else {

std::shared_ptr<OutgoingLinkLocalSession> outgoingSession(

new OutgoingLinkLocalSession(

selfJID, connector->getService().getJID(), connector->getConnection(),

&payloadParserFactories, &payloadSerializers, &xmlParserFactory));

outgoingSession->queueElement(element);

}

registerLinkLocalSession(outgoingSession);

}

connectors.erase(std::remove(connectors.begin(), connectors.end(), connector), connectors.end());

}

void Server::registerLinkLocalSession(std::shared_ptr<Session> session) {

session->onSessionFinished.connect(

boost::bind(&Server::handleLinkLocalSessionFinished, this, session));

session->onElementReceived.connect(

boost::bind(&Server::handleLinkLocalElementReceived, this, _1, session));

linkLocalSessions.push_back(session);

//tracers.push_back(std::make_shared<SessionTracer>(session));

session->startSession();

}

std::shared_ptr<Session> Server::getLinkLocalSessionForJID(const JID& jid) {

if (session->getRemoteJID() == jid) {

return session;

}

}

return std::shared_ptr<Session>();

}

std::shared_ptr<LinkLocalConnector> Server::getLinkLocalConnectorForJID(const JID& jid) {

if (connector->getService().getJID() == jid) {

return connector;

}

}

return std::shared_ptr<LinkLocalConnector>();

}

void Server::handleServiceRegistered(const DNSSDServiceID& service) {

selfJID = JID(service.getName());

}

void Server::handleRosterChanged(std::shared_ptr<RosterPayload> roster) {

if (rosterRequested) {

assert(serverFromClientSession);

std::shared_ptr<IQ> iq = IQ::createRequest(

IQ::Set, serverFromClientSession->getRemoteJID(),

idGenerator.generateID(), roster);

iq->setFrom(serverFromClientSession->getRemoteJID().toBare());

serverFromClientSession->sendElement(iq);

}

}

void Server::handlePresenceChanged(std::shared_ptr<Presence> presence) {

if (rosterRequested) {

serverFromClientSession->sendElement(presence);

}

}

void Server::handleClientConnectionServerStopped(boost::optional<BoostConnectionServer::Error> e) {

if (e) {

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/CommandConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Value.h>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

static Command::Action convertActionFromString(const std::string& action) {

if (action == "cancel") { return Command::Cancel; }

else if (action == "execute") { return Command::Execute; }

else if (action == "complete") { return Command::Complete; }

else if (action == "prev") { return Command::Prev; }

else if (action == "next") { return Command::Next; }

return Command::NoAction;

}

static std::string convertActionToString(Command::Action action) {

switch (action) {

case Command::Cancel: return "cancel";

case Command::Execute: return "execute";

case Command::Complete: return "complete";

case Command::Prev: return "prev";

case Command::Next: return "next";

case Command::NoAction: assert(false); return "";

}

assert(false);

return "";

}

CommandConvertor::CommandConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<Command>("command"),

lua_pop(L, 1);

lua_getfield(L, -1, "form");

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<Form> form = std::dynamic_pointer_cast<Form>(convertors->convertFromLuaUntyped(L, -1, "form"))) {

result->setForm(form);

}

}

lua_pop(L, 1);

return result;

}

void CommandConvertor::doConvertToLua(lua_State* L, std::shared_ptr<Command> payload) {

Lua::Table result;

if (!payload->getNode().empty()) {

result["node"] = Lua::valueRef(payload->getNode());

}

if (!payload->getSessionID().empty()) {

result["session_id"] = Lua::valueRef(payload->getSessionID());

}

switch (payload->getStatus()) {

case Command::Executing: result["status"] = Lua::valueRef("executing"); break;

case Command::Completed: result["status"] = Lua::valueRef("completed"); break;

case Command::Canceled: result["status"] = Lua::valueRef("canceled"); break;

case Command::NoStatus: break;

}

if (!payload->getNotes().empty()) {

std::vector<Lua::Value> notes;

Lua::Table noteTable;

if (!note.note.empty()) {

noteTable["note"] = Lua::valueRef(note.note);

}

switch (note.type) {

case Command::Note::Info: noteTable["type"] = Lua::valueRef("info"); break;

case Command::Note::Warn: noteTable["type"] = Lua::valueRef("warn"); break;

case Command::Note::Error: noteTable["type"] = Lua::valueRef("error"); break;

}

notes.push_back(noteTable);

}

result["notes"] = Lua::valueRef(notes);

}

if (payload->getAction() != Command::NoAction) {

result["action"] = Lua::valueRef(convertActionToString(payload->getAction()));

}

if (payload->getExecuteAction() != Command::NoAction) {

result["execute_action"] = Lua::valueRef(convertActionToString(payload->getAction()));

}

if (!payload->getAvailableActions().empty()) {

std::vector<Lua::Value> availableActions;

if (action != Command::NoAction) {

availableActions.push_back(convertActionToString(action));

}

}

result["available_actions"] = Lua::valueRef(availableActions);

}

Lua::pushValue(L, result);

if (payload->getForm()) {

bool result = convertors->convertToLuaUntyped(L, payload->getForm());

assert(result);

lua_setfield(L, -2, "form");

}

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/DOMElementConvertor.h>

#include <memory>

#include <lua.hpp>

#include <Swiften/Elements/RawXMLPayload.h>

#include <Swiften/Parser/Attribute.h>

#include <Swiften/Parser/AttributeMap.h>

#include <Swiften/Parser/XMLParser.h>

#include <Swiften/Parser/XMLParserClient.h>

#include <Swiften/Serializer/PayloadSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Debug.h>

#include <Sluift/Lua/LuaUtils.h>

using namespace Swift;

namespace {

class ParserClient : public XMLParserClient {

public:

ParserClient(lua_State* L) : L(L), currentIndex(1) {

}

virtual void handleStartElement(

const std::string& element, const std::string& ns,

const AttributeMap& attributes) SWIFTEN_OVERRIDE {

lua_checkstack(L, 6);

lua_pushnumber(L, currentIndex);

lua_newtable(L);

lua_pushstring(L, element.c_str());

lua_setfield(L, -2, "tag");

if (!ns.empty()) {

lua_pushstring(L, ns.c_str());

lua_setfield(L, -2, "ns");

}

if (!attributes.getEntries().empty()) {

lua_newtable(L);

int i = 1;

lua_pushnumber(L, i);

lua_newtable(L);

lua_pushstring(L, entry.getAttribute().getName().c_str());

lua_setfield(L, -2, "name");

if (!entry.getAttribute().getNamespace().empty()) {

lua_pushstring(L, entry.getAttribute().getNamespace().c_str());

lua_setfield(L, -2, "ns");

}

lua_pushstring(L, entry.getValue().c_str());

lua_setfield(L, -2, "value");

lua_settable(L, -3);

++i;

}

lua_setfield(L, -2, "attributes");

}

indexStack.push_back(currentIndex);

currentIndex = 1;

lua_newtable(L);

}

virtual void handleEndElement(

const std::string&, const std::string&) SWIFTEN_OVERRIDE {

lua_setfield(L, -2, "children");

lua_settable(L, -3);

currentIndex = indexStack.back();

indexStack.pop_back();

currentIndex++;

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/FormConvertor.h>

#include <memory>

#include <sstream>

#include <boost/assign/list_of.hpp>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Value.h>

using namespace Swift;

namespace {

int formIndex(lua_State* L) {

lua_getfield(L, 1, "fields");

if (lua_type(L, -1) != LUA_TTABLE) {

return 0;

}

int index = Lua::absoluteOffset(L, -1);

lua_pushnil(L);

for (lua_pushnil(L); lua_next(L, index) != 0; ) {

lua_getfield(L, -1, "name");

if (lua_equal(L, -1, 2)) {

lua_pop(L, 1);

return 1;

}

lua_pop(L, 2);

}

return 0;

}

int formNewIndex(lua_State* L) {

lua_getfield(L, 1, "fields");

bool foundField = false;

if (lua_type(L, -1) == LUA_TTABLE) {

for (lua_pushnil(L); lua_next(L, -2) != 0; ) {

lua_getfield(L, -1, "name");

case FormField::TextMultiType: type = "text-multi"; break;

case FormField::TextPrivateType: type = "text-private"; break;

case FormField::TextSingleType: type = "text-single"; break;

case FormField::JIDSingleType: type = "jid-single"; break;

case FormField::JIDMultiType: type = "jid-multi"; break;

case FormField::ListMultiType: type = "list-multi"; break;

}

if (!type.empty()) {

luaField["type"] = Lua::valueRef(type);

}

if (!field->getLabel().empty()) {

luaField["label"] = Lua::valueRef(field->getLabel());

}

if (field->getRequired()) {

luaField["required"] = Lua::boolRef(field->getRequired());

}

if (!field->getDescription().empty()) {

luaField["description"] = Lua::valueRef(field->getDescription());

}

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

luaField["value"] = Lua::boolRef(field->getBoolValue());

}

else if (field->getValues().size() > 1) {

luaField["value"] = Lua::valueRef(Lua::Array(field->getValues().begin(), field->getValues().end()));

}

else if (field->getValues().size() == 1) {

luaField["value"] = Lua::valueRef(field->getValues()[0]);

}

if (!field->getOptions().empty()) {

Lua::Array options;

Lua::Table luaOption = boost::assign::map_list_of

("label", Lua::valueRef(option.label))

("value", Lua::valueRef(option.value));

options.push_back(luaOption);

}

luaField["options"] = valueRef(options);

}

return luaField;

}

Lua::Array convertFieldListToLua(const std::vector< std::shared_ptr<FormField> >& fieldList) {

Lua::Array fields;

fields.push_back(convertFieldToLua(field));

}

return fields;

}

std::shared_ptr<FormField> convertFieldFromLua(lua_State* L) {

std::shared_ptr<FormField> result = std::make_shared<FormField>();

FormField::Type fieldType = FormField::UnknownType;

boost::optional<std::string> type = Lua::getStringField(L, -1, "type");

if (type) {

if (*type == "boolean") {

fieldType = FormField::BooleanType;

}

if (*type == "fixed") {

fieldType = FormField::FixedType;

}

if (*type == "hidden") {

fieldType = FormField::HiddenType;

}

if (*type == "list-single") {

fieldType = FormField::ListSingleType;

}

if (*type == "text-multi") {

fieldType = FormField::TextMultiType;

}

if (*type == "text-private") {

fieldType = FormField::TextPrivateType;

}

if (*type == "text-single") {

result.push_back(convertFieldFromLua(L));

lua_pop(L, 1);

}

return result;

}

std::shared_ptr<Form> convertFormFromLua(lua_State* L) {

std::shared_ptr<Form> result = std::make_shared<Form>();

if (boost::optional<std::string> title = Lua::getStringField(L, -1, "title")) {

result->setTitle(*title);

}

if (boost::optional<std::string> instructions = Lua::getStringField(L, -1, "instructions")) {

result->setInstructions(*instructions);

}

if (boost::optional<std::string> type = Lua::getStringField(L, -1, "type")) {

Form::Type formType = Form::FormType;

if (*type == "submit") {

formType = Form::SubmitType;

}

else if (*type == "cancel") {

formType = Form::CancelType;

}

else if (*type == "result") {

formType = Form::ResultType;

}

result->setType(formType);

}

lua_getfield(L, -1, "fields");

if (lua_istable(L, -1)) {

result->addField(formField);

}

}

lua_pop(L, 1);

lua_getfield(L, -1, "reported_fields");

if (lua_istable(L, -1)) {

result->addReportedField(formField);

}

}

lua_pop(L, 1);

lua_getfield(L, -1, "items");

if (lua_istable(L, -1)) {

for (lua_pushnil(L); lua_next(L, -2);) {

result->addItem(convertFieldListFromLua(L));

lua_pop(L, 1);

}

}

lua_pop(L, 1);

return result;

}

void convertFormToLua(lua_State* L, std::shared_ptr<Form> payload) {

std::string type;

switch (payload->getType()) {

case Form::FormType: type = "form"; break;

case Form::SubmitType: type = "submit"; break;

case Form::CancelType: type = "cancel"; break;

case Form::ResultType: type = "result"; break;

}

Lua::Table result = boost::assign::map_list_of("type", Lua::valueRef(type));

if (!payload->getTitle().empty()) {

result["title"] = Lua::valueRef(payload->getTitle());

}

if (!payload->getInstructions().empty()) {

result["instructions"] = Lua::valueRef(payload->getInstructions());

}

result["fields"] = valueRef(convertFieldListToLua(payload->getFields()));

if (!payload->getReportedFields().empty()) {

result["reported_fields"] = valueRef(convertFieldListToLua(payload->getReportedFields()));

}

if (!payload->getItems().empty()) {

Lua::Array luaItems;

if (!item.empty()) {

luaItems.push_back(convertFieldListToLua(item));

}

}

result["items"] = valueRef(luaItems);

}

Lua::pushValue(L, result);

lua_newtable(L);

lua_pushcfunction(L, formIndex);

lua_setfield(L, -2, "__index");

lua_pushcfunction(L, formNewIndex);

lua_setfield(L, -2, "__newindex");

lua_setmetatable(L, -2);

}

int createSubmission(lua_State* L) {

std::shared_ptr<Form> form = convertFormFromLua(L);

// Remove all redundant elements

form->setInstructions("");

form->setTitle("");

form->clearItems();

form->clearReportedFields();

std::vector< std::shared_ptr<FormField> > fields(form->getFields());

form->clearFields();

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

continue;

}

field->clearOptions();

field->setLabel("");

field->setType(FormField::UnknownType);

field->setDescription("");

form->addField(field);

}

form->setType(Form::SubmitType);

// Convert back

convertFormToLua(L, form);

Lua::registerTableToString(L, -1);

return 1;

}

}

FormConvertor::FormConvertor() : GenericLuaElementConvertor<Form>("form") {

}

FormConvertor::~FormConvertor() {

}

std::shared_ptr<Form> FormConvertor::doConvertFromLua(lua_State* L) {

return convertFormFromLua(L);

}

void FormConvertor::doConvertToLua(lua_State* L, std::shared_ptr<Form> payload) {

/*

* Copyright (c) 2014-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/ForwardedConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

ForwardedConvertor::ForwardedConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<Forwarded>("forwarded"),

convertors(convertors) {

}

ForwardedConvertor::~ForwardedConvertor() {

}

std::shared_ptr<Forwarded> ForwardedConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<Forwarded> result = std::make_shared<Forwarded>();

lua_getfield(L, -1, "delay");

if (!lua_isnil(L, -1)) {

std::shared_ptr<Delay> delay = std::dynamic_pointer_cast<Delay>(convertors->convertFromLuaUntyped(L, -1, "delay"));

if (!!delay) {

result->setDelay(delay);

}

}

lua_pop(L, 1);

lua_getfield(L, -1, "stanza");

if (!lua_isnil(L, -1)) {

std::shared_ptr<Stanza> stanza = std::dynamic_pointer_cast<Stanza>(convertors->convertFromLua(L, -1));

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubAffiliationsConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubAffiliationsConvertor::PubSubAffiliationsConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubAffiliations>("pubsub_affiliations"),

convertors(convertors) {

}

PubSubAffiliationsConvertor::~PubSubAffiliationsConvertor() {

}

std::shared_ptr<PubSubAffiliations> PubSubAffiliationsConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubAffiliations> result = std::make_shared<PubSubAffiliations>();

lua_getfield(L, -1, "node");

if (lua_isstring(L, -1)) {

result->setNode(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<PubSubAffiliation> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<PubSubAffiliation> payload = std::dynamic_pointer_cast<PubSubAffiliation>(convertors->convertFromLuaUntyped(L, -1, "pubsub_affiliation"))) {

items.push_back(payload);

}

}

lua_pop(L, 1);

}

result->setAffiliations(items);

}

return result;

}

void PubSubAffiliationsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubAffiliations> payload) {

lua_createtable(L, 0, 0);

if (payload->getNode()) {

lua_pushstring(L, (*payload->getNode()).c_str());

lua_setfield(L, -2, "node");

}

if (!payload->getAffiliations().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

}

}

boost::optional<LuaElementConvertor::Documentation> PubSubAffiliationsConvertor::getDocumentation() const {

return Documentation(

"PubSubAffiliations",

"This table has the following fields:\n\n"

"- `node`: string (Optional)\n"

"- `affiliations`: array<@{PubSubAffiliation}>\n"

);

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubEventItemConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubEventItemConvertor::PubSubEventItemConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubEventItem>("pubsub_event_item"),

convertors(convertors) {

}

PubSubEventItemConvertor::~PubSubEventItemConvertor() {

}

std::shared_ptr<PubSubEventItem> PubSubEventItemConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubEventItem> result = std::make_shared<PubSubEventItem>();

lua_getfield(L, -1, "node");

if (lua_isstring(L, -1)) {

result->setNode(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

lua_getfield(L, -1, "publisher");

if (lua_isstring(L, -1)) {

result->setPublisher(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

lua_getfield(L, -1, "data");

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<Payload> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

}

}

lua_pop(L, 1);

}

result->setData(items);

}

lua_pop(L, 1);

lua_getfield(L, -1, "id");

if (lua_isstring(L, -1)) {

result->setID(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

return result;

}

void PubSubEventItemConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubEventItem> payload) {

lua_createtable(L, 0, 0);

if (payload->getNode()) {

lua_pushstring(L, (*payload->getNode()).c_str());

lua_setfield(L, -2, "node");

}

if (payload->getPublisher()) {

lua_pushstring(L, (*payload->getPublisher()).c_str());

lua_setfield(L, -2, "publisher");

}

if (!payload->getData().empty()) {

lua_createtable(L, boost::numeric_cast<int>(payload->getData().size()), 0);

{

int i = 0;

if (convertors->convertToLua(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

lua_setfield(L, -2, "data");

}

if (payload->getID()) {

lua_pushstring(L, (*payload->getID()).c_str());

lua_setfield(L, -2, "id");

}

}

boost::optional<LuaElementConvertor::Documentation> PubSubEventItemConvertor::getDocumentation() const {

return Documentation(

"PubSubEventItem",

"This table has the following fields:\n\n"

"- `node`: string (Optional)\n"

"- `publisher`: string (Optional)\n"

"- `data`: array<element (table)>\n"

"- `id`: string (Optional)\n"

);

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubEventItemsConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubEventItemsConvertor::PubSubEventItemsConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubEventItems>("pubsub_event_items"),

convertors(convertors) {

}

PubSubEventItemsConvertor::~PubSubEventItemsConvertor() {

}

std::shared_ptr<PubSubEventItems> PubSubEventItemsConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubEventItems> result = std::make_shared<PubSubEventItems>();

lua_getfield(L, -1, "node");

if (lua_isstring(L, -1)) {

result->setNode(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

lua_getfield(L, -1, "items");

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<PubSubEventItem> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<PubSubEventItem> payload = std::dynamic_pointer_cast<PubSubEventItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_item"))) {

items.push_back(payload);

}

}

}

lua_pop(L, 1);

lua_getfield(L, -1, "retracts");

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<PubSubEventRetract> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<PubSubEventRetract> payload = std::dynamic_pointer_cast<PubSubEventRetract>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_retract"))) {

items.push_back(payload);

}

}

lua_pop(L, 1);

}

result->setRetracts(items);

}

lua_pop(L, 1);

return result;

}

void PubSubEventItemsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubEventItems> payload) {

lua_createtable(L, 0, 0);

lua_pushstring(L, payload->getNode().c_str());

lua_setfield(L, -2, "node");

if (!payload->getItems().empty()) {

lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

lua_setfield(L, -2, "items");

}

if (!payload->getRetracts().empty()) {

lua_createtable(L, boost::numeric_cast<int>(payload->getRetracts().size()), 0);

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

lua_setfield(L, -2, "retracts");

}

}

boost::optional<LuaElementConvertor::Documentation> PubSubEventItemsConvertor::getDocumentation() const {

return Documentation(

"PubSubEventItems",

"This table has the following fields:\n\n"

"- `node`: string\n"

"- `items`: array<@{PubSubEventItem}>\n"

"- `retracts`: array<@{PubSubEventRetract}>\n"

);

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubItemConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubItemConvertor::PubSubItemConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubItem>("pubsub_item"),

convertors(convertors) {

}

PubSubItemConvertor::~PubSubItemConvertor() {

}

std::shared_ptr<PubSubItem> PubSubItemConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubItem> result = std::make_shared<PubSubItem>();

lua_getfield(L, -1, "data");

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<Payload> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<Payload> payload = std::dynamic_pointer_cast<Payload>(convertors->convertFromLua(L, -1))) {

items.push_back(payload);

}

}

lua_pop(L, 1);

}

result->setData(items);

}

lua_pop(L, 1);

lua_getfield(L, -1, "id");

if (lua_isstring(L, -1)) {

result->setID(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

return result;

}

void PubSubItemConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubItem> payload) {

lua_createtable(L, 0, 0);

if (!payload->getData().empty()) {

lua_createtable(L, boost::numeric_cast<int>(payload->getData().size()), 0);

{

int i = 0;

if (convertors->convertToLua(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

lua_setfield(L, -2, "data");

}

lua_pushstring(L, payload->getID().c_str());

lua_setfield(L, -2, "id");

}

boost::optional<LuaElementConvertor::Documentation> PubSubItemConvertor::getDocumentation() const {

return Documentation(

"PubSubItem",

"This table has the following fields:\n\n"

"- `data`: array<element (table)>\n"

"- `id`: string\n"

);

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubItemsConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubItemsConvertor::PubSubItemsConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubItems>("pubsub_items"),

convertors(convertors) {

}

PubSubItemsConvertor::~PubSubItemsConvertor() {

}

std::shared_ptr<PubSubItems> PubSubItemsConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubItems> result = std::make_shared<PubSubItems>();

lua_getfield(L, -1, "node");

if (lua_isstring(L, -1)) {

result->setNode(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<PubSubItem> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<PubSubItem> payload = std::dynamic_pointer_cast<PubSubItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_item"))) {

items.push_back(payload);

}

}

lua_pop(L, 1);

}

result->setItems(items);

}

lua_getfield(L, -1, "maximum_items");

if (lua_isnumber(L, -1)) {

result->setMaximumItems(boost::numeric_cast<unsigned int>(lua_tonumber(L, -1)));

}

lua_pop(L, 1);

lua_getfield(L, -1, "subscription_id");

if (lua_isstring(L, -1)) {

result->setSubscriptionID(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

return result;

}

void PubSubItemsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubItems> payload) {

lua_createtable(L, 0, 0);

lua_pushstring(L, payload->getNode().c_str());

lua_setfield(L, -2, "node");

if (!payload->getItems().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

}

if (payload->getMaximumItems()) {

lua_pushnumber(L, (*payload->getMaximumItems()));

lua_setfield(L, -2, "maximum_items");

}

if (payload->getSubscriptionID()) {

lua_pushstring(L, (*payload->getSubscriptionID()).c_str());

lua_setfield(L, -2, "subscription_id");

}

}

boost::optional<LuaElementConvertor::Documentation> PubSubItemsConvertor::getDocumentation() const {

return Documentation(

"PubSubItems",

"This table has the following fields:\n\n"

"- `node`: string\n"

"- `items`: array<@{PubSubItem}>\n"

"- `maximum_items`: number (Optional)\n"

"- `subscription_id`: string (Optional)\n"

);

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubOwnerAffiliationsConvertor::PubSubOwnerAffiliationsConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubOwnerAffiliations>("pubsub_owner_affiliations"),

convertors(convertors) {

}

PubSubOwnerAffiliationsConvertor::~PubSubOwnerAffiliationsConvertor() {

}

std::shared_ptr<PubSubOwnerAffiliations> PubSubOwnerAffiliationsConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubOwnerAffiliations> result = std::make_shared<PubSubOwnerAffiliations>();

lua_getfield(L, -1, "node");

if (lua_isstring(L, -1)) {

result->setNode(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<PubSubOwnerAffiliation> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<PubSubOwnerAffiliation> payload = std::dynamic_pointer_cast<PubSubOwnerAffiliation>(convertors->convertFromLuaUntyped(L, -1, "pubsub_owner_affiliation"))) {

items.push_back(payload);

}

}

lua_pop(L, 1);

}

result->setAffiliations(items);

}

return result;

}

void PubSubOwnerAffiliationsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubOwnerAffiliations> payload) {

lua_createtable(L, 0, 0);

lua_pushstring(L, payload->getNode().c_str());

lua_setfield(L, -2, "node");

if (!payload->getAffiliations().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

}

}

boost::optional<LuaElementConvertor::Documentation> PubSubOwnerAffiliationsConvertor::getDocumentation() const {

return Documentation(

"PubSubOwnerAffiliations",

"This table has the following fields:\n\n"

"- `node`: string\n"

"- `affiliations`: array<@{PubSubOwnerAffiliation}>\n"

);

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubOwnerSubscriptionsConvertor::PubSubOwnerSubscriptionsConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubOwnerSubscriptions>("pubsub_owner_subscriptions"),

convertors(convertors) {

}

PubSubOwnerSubscriptionsConvertor::~PubSubOwnerSubscriptionsConvertor() {

}

std::shared_ptr<PubSubOwnerSubscriptions> PubSubOwnerSubscriptionsConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubOwnerSubscriptions> result = std::make_shared<PubSubOwnerSubscriptions>();

lua_getfield(L, -1, "node");

if (lua_isstring(L, -1)) {

result->setNode(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<PubSubOwnerSubscription> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<PubSubOwnerSubscription> payload = std::dynamic_pointer_cast<PubSubOwnerSubscription>(convertors->convertFromLuaUntyped(L, -1, "pubsub_owner_subscription"))) {

items.push_back(payload);

}

}

lua_pop(L, 1);

}

result->setSubscriptions(items);

}

return result;

}

void PubSubOwnerSubscriptionsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubOwnerSubscriptions> payload) {

lua_createtable(L, 0, 0);

lua_pushstring(L, payload->getNode().c_str());

lua_setfield(L, -2, "node");

if (!payload->getSubscriptions().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

}

}

boost::optional<LuaElementConvertor::Documentation> PubSubOwnerSubscriptionsConvertor::getDocumentation() const {

return Documentation(

"PubSubOwnerSubscriptions",

"This table has the following fields:\n\n"

"- `node`: string\n"

"- `subscriptions`: array<@{PubSubOwnerSubscription}>\n"

);

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubPublishConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubPublishConvertor::PubSubPublishConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubPublish>("pubsub_publish"),

convertors(convertors) {

}

PubSubPublishConvertor::~PubSubPublishConvertor() {

}

std::shared_ptr<PubSubPublish> PubSubPublishConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubPublish> result = std::make_shared<PubSubPublish>();

lua_getfield(L, -1, "node");

if (lua_isstring(L, -1)) {

result->setNode(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

lua_getfield(L, -1, "items");

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<PubSubItem> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<PubSubItem> payload = std::dynamic_pointer_cast<PubSubItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_item"))) {

items.push_back(payload);

}

}

lua_pop(L, 1);

}

result->setItems(items);

}

lua_pop(L, 1);

return result;

}

void PubSubPublishConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubPublish> payload) {

lua_createtable(L, 0, 0);

lua_pushstring(L, payload->getNode().c_str());

lua_setfield(L, -2, "node");

if (!payload->getItems().empty()) {

lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

lua_setfield(L, -2, "items");

}

}

boost::optional<LuaElementConvertor::Documentation> PubSubPublishConvertor::getDocumentation() const {

return Documentation(

"PubSubPublish",

"This table has the following fields:\n\n"

"- `node`: string\n"

"- `items`: array<@{PubSubItem}>\n"

);

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubRetractConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubRetractConvertor::PubSubRetractConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubRetract>("pubsub_retract"),

convertors(convertors) {

}

PubSubRetractConvertor::~PubSubRetractConvertor() {

}

std::shared_ptr<PubSubRetract> PubSubRetractConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubRetract> result = std::make_shared<PubSubRetract>();

lua_getfield(L, -1, "node");

if (lua_isstring(L, -1)) {

result->setNode(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

lua_getfield(L, -1, "items");

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<PubSubItem> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<PubSubItem> payload = std::dynamic_pointer_cast<PubSubItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_item"))) {

items.push_back(payload);

}

}

lua_pop(L, 1);

}

result->setItems(items);

}

lua_pop(L, 1);

lua_getfield(L, -1, "notify");

if (lua_isboolean(L, -1)) {

result->setNotify(lua_toboolean(L, -1));

}

lua_pop(L, 1);

return result;

}

void PubSubRetractConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubRetract> payload) {

lua_createtable(L, 0, 0);

lua_pushstring(L, payload->getNode().c_str());

lua_setfield(L, -2, "node");

if (!payload->getItems().empty()) {

lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

lua_setfield(L, -2, "items");

}

if (payload->isNotify().is_initialized()) {

lua_pushboolean(L, payload->isNotify().get_value_or(false));

lua_setfield(L, -2, "notify");

}

}

boost::optional<LuaElementConvertor::Documentation> PubSubRetractConvertor::getDocumentation() const {

return Documentation(

"PubSubRetract",

"This table has the following fields:\n\n"

"- `node`: string\n"

"- `items`: array<@{PubSubItem}>\n"

"- `notify`: boolean\n"

);

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/PubSubSubscriptionsConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Sluift/LuaElementConvertors.h>

using namespace Swift;

PubSubSubscriptionsConvertor::PubSubSubscriptionsConvertor(LuaElementConvertors* convertors) :

GenericLuaElementConvertor<PubSubSubscriptions>("pubsub_subscriptions"),

convertors(convertors) {

}

PubSubSubscriptionsConvertor::~PubSubSubscriptionsConvertor() {

}

std::shared_ptr<PubSubSubscriptions> PubSubSubscriptionsConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<PubSubSubscriptions> result = std::make_shared<PubSubSubscriptions>();

lua_getfield(L, -1, "node");

if (lua_isstring(L, -1)) {

result->setNode(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::shared_ptr<PubSubSubscription> > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

if (std::shared_ptr<PubSubSubscription> payload = std::dynamic_pointer_cast<PubSubSubscription>(convertors->convertFromLuaUntyped(L, -1, "pubsub_subscription"))) {

items.push_back(payload);

}

}

lua_pop(L, 1);

}

result->setSubscriptions(items);

}

return result;

}

void PubSubSubscriptionsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubSubscriptions> payload) {

lua_createtable(L, 0, 0);

if (payload->getNode()) {

lua_pushstring(L, (*payload->getNode()).c_str());

lua_setfield(L, -2, "node");

}

if (!payload->getSubscriptions().empty()) {

{

int i = 0;

if (convertors->convertToLuaUntyped(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

}

}

boost::optional<LuaElementConvertor::Documentation> PubSubSubscriptionsConvertor::getDocumentation() const {

return Documentation(

"PubSubSubscriptions",

"This table has the following fields:\n\n"

"- `node`: string (Optional)\n"

"- `subscriptions`: array<@{PubSubSubscription}>\n"

);

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/ElementConvertors/SecurityLabelConvertor.h>

#include <memory>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

using namespace Swift;

SecurityLabelConvertor::SecurityLabelConvertor() :

GenericLuaElementConvertor<SecurityLabel>("security_label") {

}

SecurityLabelConvertor::~SecurityLabelConvertor() {

}

std::shared_ptr<SecurityLabel> SecurityLabelConvertor::doConvertFromLua(lua_State* L) {

std::shared_ptr<SecurityLabel> result = std::make_shared<SecurityLabel>();

lua_getfield(L, -1, "equivalent_labels");

if (lua_type(L, -1) == LUA_TTABLE) {

std::vector< std::string > items;

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (lua_isstring(L, -1)) {

items.push_back(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

}

result->setEquivalentLabels(items);

}

lua_pop(L, 1);

lua_getfield(L, -1, "foreground_color");

if (lua_isstring(L, -1)) {

result->setForegroundColor(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

lua_getfield(L, -1, "display_marking");

if (lua_isstring(L, -1)) {

result->setDisplayMarking(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

lua_getfield(L, -1, "background_color");

if (lua_isstring(L, -1)) {

result->setBackgroundColor(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

lua_getfield(L, -1, "label");

if (lua_isstring(L, -1)) {

result->setLabel(std::string(lua_tostring(L, -1)));

}

lua_pop(L, 1);

return result;

}

void SecurityLabelConvertor::doConvertToLua(lua_State* L, std::shared_ptr<SecurityLabel> payload) {

lua_createtable(L, 0, 0);

if (!payload->getEquivalentLabels().empty()) {

lua_createtable(L, boost::numeric_cast<int>(payload->getEquivalentLabels().size()), 0);

{

int i = 0;

lua_pushstring(L, item.c_str());

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

lua_setfield(L, -2, "equivalent_labels");

}

lua_pushstring(L, payload->getForegroundColor().c_str());

lua_setfield(L, -2, "foreground_color");

lua_pushstring(L, payload->getDisplayMarking().c_str());

lua_setfield(L, -2, "display_marking");

lua_pushstring(L, payload->getBackgroundColor().c_str());

lua_setfield(L, -2, "background_color");

lua_pushstring(L, payload->getLabel().c_str());

lua_setfield(L, -2, "label");

}

boost::optional<LuaElementConvertor::Documentation> SecurityLabelConvertor::getDocumentation() const {

return Documentation(

"SecurityLabel",

"This table has the following fields:\n\n"

"- `equivalent_labels`: array<string>\n"

"- `foreground_color`: string\n"

"- `display_marking`: string\n"

"- `background_color`: string\n"

"- `label`: string\n"

);

}

/*

* Copyright (c) 2014-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/numeric/conversion/cast.hpp>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Elements/Presence.h>

#include <Sluift/GenericLuaElementConvertor.h>

#include <Sluift/Lua/Exception.h>

#include <Sluift/LuaElementConvertors.h>

namespace Swift {

template <typename T> class StanzaConvertor : public GenericLuaElementConvertor<T> {

public:

StanzaConvertor(const std::string& tag)

: GenericLuaElementConvertor<T>(tag) {

}

virtual ~StanzaConvertor() {

}

std::shared_ptr<T> getStanza(lua_State* L, LuaElementConvertors* convertors) {

std::shared_ptr<T> result = std::make_shared<T>();

lua_getfield(L, -1, "id");

if (lua_isstring(L, -1)) {

result->setID(lua_tostring(L, -1));

}

lua_pop(L, 1);

lua_getfield(L, -1, "from");

if (lua_isstring(L, -1)) {

result->setFrom(lua_tostring(L, -1));

}

lua_getfield(L, -1, "payloads");

if (lua_type(L, -1) == LUA_TTABLE) {

for(size_t i = 0; i < lua_objlen(L, -1); ++i) {

lua_pushnumber(L, i + 1);

lua_gettable(L, -2);

if (!lua_isnil(L, -1)) {

std::shared_ptr<Payload> payload = std::dynamic_pointer_cast<Payload>(convertors->convertFromLua(L, -1));

if (!!payload) {

result->addPayload(payload);

}

}

lua_pop(L, 1);

}

}

lua_pop(L, 1);

return result;

}

void pushStanza(lua_State* L, const std::shared_ptr<T> stanza, LuaElementConvertors* convertors) {

lua_createtable(L, 0, 0);

lua_pushstring(L, stanza->getID().c_str());

lua_setfield(L, -2, "id");

lua_pushstring(L, stanza->getFrom().toString().c_str());

lua_setfield(L, -2, "from");

lua_pushstring(L, stanza->getTo().toString().c_str());

lua_setfield(L, -2, "to");

if (!stanza->getPayloads().empty()) {

lua_createtable(L, boost::numeric_cast<int>(stanza->getPayloads().size()), 0);

{

int i = 0;

if (convertors->convertToLua(L, item) > 0) {

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

++i;

}

}

}

lua_setfield(L, -2, "payloads");

}

}

};

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/Lua/FunctionRegistry.h>

#include <Sluift/Lua/Exception.h>

#include <Sluift/Lua/LuaUtils.h>

#include <Sluift/globals.h>

using namespace Swift::Lua;

FunctionRegistry::FunctionRegistry() {

}

FunctionRegistry::~FunctionRegistry() {

}

FunctionRegistry& FunctionRegistry::getInstance() {

static FunctionRegistry instance;

return instance;

}

void FunctionRegistry::addFunction(

const std::string& name, lua_CFunction function, const std::string& type,

const std::string& helpDescription, const std::string& helpParameters, const std::string& helpOptions) {

Registration registration;

registration.name = name;

registration.function = function;

registration.type = type;

registration.helpDescription = helpDescription;

registration.helpParameters = helpParameters;

registration.helpOptions = helpOptions;

registrations.push_back(registration);

}

void FunctionRegistry::createFunctionTable(lua_State* L, const std::string& type) {

lua_newtable(L);

addFunctionsToTable(L, type);

}

void FunctionRegistry::addFunctionsToTable(lua_State* L, const std::string& type) {

if (registration.type == type) {

lua_pushcclosure(L, registration.function, 0);

if (!registration.helpDescription.empty()) {

Lua::registerHelp(L, -1, registration.helpDescription, registration.helpParameters, registration.helpOptions);

}

else {

Lua::registerExtraHelp(L, -1, registration.type + "." + registration.name);

}

lua_setfield(L, -2, registration.name.c_str());

}

}

}

/*

* Copyright (c) 2011-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/Lua/Value.h>

#include <boost/numeric/conversion/cast.hpp>

#include <boost/variant/apply_visitor.hpp>

extern "C" {

#include <lualib.h>

}

using namespace Swift;

using namespace Swift::Lua;

namespace {

struct PushVisitor : public boost::static_visitor<> {

PushVisitor(lua_State* state) : state(state) {

}

void operator()(const Nil&) const {

lua_pushnil(state);

}

void operator()(const bool& b) const {

lua_pushboolean(state, b);

}

void operator()(const int& i) const {

lua_pushnumber(state, i);

}

void operator()(const std::string& s) const {

lua_pushstring(state, s.c_str());

}

void operator()(const std::vector<Value>& values) const {

lua_createtable(state, boost::numeric_cast<int>(values.size()), 0);

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

boost::apply_visitor(PushVisitor(state), values[i]);

lua_rawseti(state, -2, boost::numeric_cast<int>(i + 1));

}

}

void operator()(const std::map<std::string, std::shared_ptr<Value> >& table) const {

lua_createtable(state, 0, boost::numeric_cast<int>(table.size()));

boost::apply_visitor(PushVisitor(state), *i.second);

lua_setfield(state, -2, i.first.c_str());

}

}

lua_State* state;

};

}

namespace Swift { namespace Lua {

void pushValue(lua_State* state, const Value& value) {

boost::apply_visitor(PushVisitor(state), value);

}

}}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/LuaElementConvertors.h>

#include <memory>

#include <Sluift/ElementConvertors/BodyConvertor.h>

#include <Sluift/ElementConvertors/CarbonsReceivedConvertor.h>

#include <Sluift/ElementConvertors/CarbonsSentConvertor.h>

#include <Sluift/ElementConvertors/CommandConvertor.h>

#include <Sluift/ElementConvertors/DOMElementConvertor.h>

#include <Sluift/ElementConvertors/DefaultElementConvertor.h>

#include <Sluift/ElementConvertors/DelayConvertor.h>

#include <Sluift/ElementConvertors/DiscoInfoConvertor.h>

#include <Sluift/ElementConvertors/DiscoItemsConvertor.h>

#include <Sluift/ElementConvertors/FormConvertor.h>

#include <Sluift/ElementConvertors/ForwardedConvertor.h>

#include <Sluift/ElementConvertors/IQConvertor.h>

#include <Sluift/ElementConvertors/MAMFinConvertor.h>

#include <Sluift/ElementConvertors/MAMQueryConvertor.h>

#include <Sluift/ElementConvertors/MAMResultConvertor.h>

#include <Sluift/ElementConvertors/MessageConvertor.h>

#include <Sluift/ElementConvertors/PresenceConvertor.h>

#include <Sluift/ElementConvertors/PubSubEventConvertor.h>

#include <Sluift/ElementConvertors/RawXMLElementConvertor.h>

#include <Sluift/ElementConvertors/ResultSetConvertor.h>

#include <Sluift/ElementConvertors/SoftwareVersionConvertor.h>

#include <Sluift/ElementConvertors/StatusConvertor.h>

#include <Sluift/ElementConvertors/StatusShowConvertor.h>

#include <Sluift/ElementConvertors/SubjectConvertor.h>

#include <Sluift/ElementConvertors/VCardConvertor.h>

#include <Sluift/ElementConvertors/VCardUpdateConvertor.h>

#include <Sluift/Lua/Exception.h>

#include <Sluift/Lua/LuaUtils.h>

#include <Sluift/LuaElementConvertor.h>

convertors.push_back(std::make_shared<CarbonsReceivedConvertor>(this));

convertors.push_back(std::make_shared<CarbonsSentConvertor>(this));

convertors.push_back(std::make_shared<DOMElementConvertor>());

convertors.push_back(std::make_shared<RawXMLElementConvertor>());

convertors.push_back(std::make_shared<DefaultElementConvertor>());

}

LuaElementConvertors::~LuaElementConvertors() {

}

#include <Sluift/ElementConvertors/ElementConvertors.ipp>

std::shared_ptr<Element> LuaElementConvertors::convertFromLua(lua_State* L, int index) {

if (lua_isstring(L, index)) {

return convertFromLuaUntyped(L, index, "xml");

}

else if (lua_istable(L, index)) {

lua_getfield(L, index, "_type");

if (lua_isstring(L, -1)) {

std::string type = lua_tostring(L, -1);

lua_pop(L, 1);

return convertFromLuaUntyped(L, index, type);

}

lua_pop(L, 1);

}

throw Lua::Exception("Unable to determine type");

}

std::shared_ptr<Element> LuaElementConvertors::convertFromLuaUntyped(lua_State* L, int index, const std::string& type) {

index = Lua::absoluteOffset(L, index);

if (std::shared_ptr<Element> result = convertor->convertFromLua(L, index, type)) {

return result;

}

}

return std::shared_ptr<Element>();

}

int LuaElementConvertors::convertToLua(lua_State* L, std::shared_ptr<Element> payload) {

if (boost::optional<std::string> type = doConvertToLuaUntyped(L, payload)) {

if (lua_istable(L, -1)) {

lua_pushstring(L, type->c_str());

lua_setfield(L, -2, "_type");

Lua::registerTableToString(L, -1);

}

else {

assert(*type == "xml");

}

return 1;

}

return 0;

}

int LuaElementConvertors::convertToLuaUntyped(lua_State* L, std::shared_ptr<Element> payload) {

if (doConvertToLuaUntyped(L, payload)) {

return 1;

}

return 0;

}

boost::optional<std::string> LuaElementConvertors::doConvertToLuaUntyped(

lua_State* L, std::shared_ptr<Element> payload) {

if (!payload) {

return LuaElementConvertor::NO_RESULT;

}

if (boost::optional<std::string> type = convertor->convertToLua(L, payload)) {

return *type;

}

}

return LuaElementConvertor::NO_RESULT;

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/assign/list_of.hpp>

#include <boost/lambda/bind.hpp>

#include <boost/lambda/lambda.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Disco/ClientDiscoManager.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/RawXMLPayload.h>

#include <Swiften/Elements/RosterItemPayload.h>

#include <Swiften/Elements/RosterPayload.h>

#include <Swiften/Elements/SoftwareVersion.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Presence/PresenceSender.h>

#include <Swiften/Presence/SubscriptionManager.h>

#include <Swiften/Queries/GenericRequest.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/Requests/GetSoftwareVersionRequest.h>

#include <Swiften/Roster/SetRosterRequest.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterItem.h>

#include <Swiften/TLS/PKCS12Certificate.h>

#include <Sluift/ElementConvertors/IQConvertor.h>

#include <Sluift/ElementConvertors/MessageConvertor.h>

#include <Sluift/ElementConvertors/PresenceConvertor.h>

#include <Sluift/ElementConvertors/StanzaConvertor.h>

#include <Sluift/ElementConvertors/StatusShowConvertor.h>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Exception.h>

#include <Sluift/Lua/FunctionRegistration.h>

#include <Sluift/Lua/LuaUtils.h>

#include <Sluift/Lua/Value.h>

#include <Sluift/SluiftClient.h>

SLUIFT_LUA_FUNCTION_WITH_HELP(

Client, set_version,

"Sets the published version of this client.",

"self",

"name the name of the client software\n"

"version the version identifier of this client\n"

"os the OS this client is running on\n"

) {

Sluift::globals.eventLoop.runOnce();

SluiftClient* client = getClient(L);

if (std::shared_ptr<SoftwareVersion> version = std::dynamic_pointer_cast<SoftwareVersion>(Sluift::globals.elementConvertor.convertFromLuaUntyped(L, 2, "software_version"))) {

client->setSoftwareVersion(version->getName(), version->getVersion(), version->getOS());

}

return 0;

}

SLUIFT_LUA_FUNCTION_WITH_HELP(

Client, get_contacts,

"Returns a table of all the contacts in the contact list.",

"self\n",

""

) {

Sluift::globals.eventLoop.runOnce();

SluiftClient* client = getClient(L);

Lua::Table contactsTable;

std::string subscription;

switch(item.getSubscription()) {

case RosterItemPayload::None: subscription = "none"; break;

case RosterItemPayload::To: subscription = "to"; break;

case RosterItemPayload::From: subscription = "from"; break;

case RosterItemPayload::Both: subscription = "both"; break;

case RosterItemPayload::Remove: subscription = "remove"; break;

}

Lua::Table itemTable = boost::assign::map_list_of

("jid", std::make_shared<Lua::Value>(item.getJID().toString()))

("name", std::make_shared<Lua::Value>(item.getName()))

("subscription", std::make_shared<Lua::Value>(subscription))

("groups", std::make_shared<Lua::Value>(std::vector<Lua::Value>(item.getGroups().begin(), item.getGroups().end())));

contactsTable[item.getJID().toString()] = std::make_shared<Lua::Value>(itemTable);

}

pushValue(L, contactsTable);

Lua::registerTableToString(L, -1);

return 1;

}

SLUIFT_LUA_FUNCTION_WITH_HELP(

Client, send_message,

"Send a message.",

"self\n"

"to the JID to send the message to\n"

"body the body of the message. Can alternatively be specified using the `body` option\n",

"to the JID to send the message to\n"

"body the body of the message\n"

"subject the subject of the MUC room to set\n"

/*

* Copyright (c) 2014-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/assign/list_of.hpp>

#include <boost/lambda/bind.hpp>

#include <boost/lambda/lambda.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/MAMQuery.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/RawXMLPayload.h>

#include <Swiften/Elements/RosterItemPayload.h>

#include <Swiften/Elements/RosterPayload.h>

#include <Swiften/Elements/SoftwareVersion.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Presence/PresenceSender.h>

#include <Swiften/Presence/SubscriptionManager.h>

#include <Swiften/Queries/GenericRequest.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/Requests/GetSoftwareVersionRequest.h>

#include <Swiften/Roster/SetRosterRequest.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterItem.h>

#include <Sluift/ElementConvertors/IQConvertor.h>

#include <Sluift/ElementConvertors/MessageConvertor.h>

#include <Sluift/ElementConvertors/PresenceConvertor.h>

#include <Sluift/ElementConvertors/StanzaConvertor.h>

#include <Sluift/ElementConvertors/StatusShowConvertor.h>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Exception.h>

#include <Sluift/Lua/FunctionRegistration.h>

#include <Sluift/Lua/LuaUtils.h>

#include <Sluift/Lua/Value.h>

#include <Sluift/SluiftComponent.h>

#include <Sluift/globals.h>

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <string>

#include <vector>

#include <boost/program_options/options_description.hpp>

#include <boost/program_options/variables_map.hpp>

#include <boost/version.hpp>

#include <Sluift/globals.h>

#include <Sluift/Console.h>

#include <Sluift/StandardTerminal.h>

#include <Sluift/sluift.h>

#include <Sluift/Lua/LuaUtils.h>

#ifdef HAVE_EDITLINE

#include <Sluift/EditlineTerminal.h>

#endif

#include <Sluift/Version.h>

using namespace Swift;

#ifdef SWIFTEN_PLATFORM_WINDOWS

#define EXIT_KEY "Z"

#else

#define EXIT_KEY "D"

#endif

static const std::string SLUIFT_WELCOME_STRING(

"== Sluift XMPP Console (" SLUIFT_VERSION_STRING ")\nPress Ctrl-" EXIT_KEY " to exit. Type help() for help.");

static const luaL_Reg defaultLibraries[] = {

{"", luaopen_base},

{LUA_LOADLIBNAME, luaopen_package},

{LUA_TABLIBNAME, luaopen_table},

{LUA_IOLIBNAME, luaopen_io},

{LUA_OSLIBNAME, luaopen_os},

{LUA_STRLIBNAME, luaopen_string},

{LUA_MATHLIBNAME, luaopen_math},

{LUA_DBLIBNAME, luaopen_debug},

throw std::runtime_error(errorMessage ? errorMessage : "Unknown error");

}

}

static void initialize(lua_State* L) {

lua_gc(L, LUA_GCSTOP, 0);

for (const luaL_Reg* lib = defaultLibraries; lib->func; lib++) {

#if LUA_VERSION_NUM >= 502

luaL_requiref(L, lib->name, lib->func, 1);

lua_pop(L, 1);

#else

lua_pushcfunction(L, lib->func);

lua_pushstring(L, lib->name);

lua_call(L, 1, 0);

#endif

}

lua_gc(L, LUA_GCRESTART, 0);

}

static void runScript(lua_State* L, const std::string& script, const std::vector<std::string>& scriptArguments) {

// Create arguments table

lua_createtable(L, boost::numeric_cast<int>(scriptArguments.size()), 0);

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

lua_pushstring(L, scriptArguments[i].c_str());

lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));

}

lua_setglobal(L, "arg");

// Load file

checkResult(L, luaL_loadfile(L, script.c_str()));

lua_pushstring(L, scriptArgument.c_str());

}

checkResult(L, Console::call(L, boost::numeric_cast<int>(scriptArguments.size()), false));

}

int main(int argc, char* argv[]) {

// Parse program options

boost::program_options::options_description visibleOptions("Options");

visibleOptions.add_options()

("help,h", "Display this help message")

("version,v", "Display version information")

("interactive,i", "Enter interactive mode after executing script")

;

boost::program_options::options_description hiddenOptions("Hidden Options");

hiddenOptions.add_options()

("script", boost::program_options::value< std::string >(), "Script to be executed")

("script-arguments", boost::program_options::value< std::vector<std::string> >(), "Script arguments")

;

boost::program_options::options_description options("All Options");

options.add(visibleOptions).add(hiddenOptions);

boost::program_options::positional_options_description positional_options;

positional_options.add("script", 1).add("script-arguments", -1);

boost::program_options::variables_map arguments;

try {

boost::program_options::store(

boost::program_options::command_line_parser(argc, argv)

.options(options)

.positional(positional_options).run(), arguments);

if (arguments.count("help")) {

std::cout << visibleOptions << "\n";

return 0;

}

else if (arguments.count("version")) {

std::cout << SLUIFT_VERSION_STRING;

return 0;

}

lua_State* L = luaL_newstate();

initialize(L);

try {

// Run script

if (arguments.count("script")) {

std::vector<std::string> scriptArguments;

if (arguments.count("script-arguments")) {

scriptArguments = arguments["script-arguments"].as< std::vector<std::string> >();

}

runScript(L, arguments["script"].as<std::string>(), scriptArguments);

}

// Run console

if (arguments.count("interactive") || arguments.count("script") == 0) {

// Set up signal handler

signal(SIGINT, handleInterruptSignal);

// Import some useful functions into the global namespace

lua_getglobal(L, "sluift");

std::vector<std::string> globalImports = boost::assign::list_of

("help")("with");

lua_getfield(L, -1, globalImport.c_str());

lua_setglobal(L, globalImport.c_str());

}

lua_pop(L, 1);

std::cout << SLUIFT_WELCOME_STRING << std::endl;

#ifdef HAVE_EDITLINE

EditlineTerminal& terminal = EditlineTerminal::getInstance();

#else

StandardTerminal terminal;

#endif

Console console(L, &terminal);

console.run();

}

}

catch (const std::exception& e) {

std::cerr << e.what() << std::endl;

lua_close(L);

return -1;

}

lua_close(L);

return 0;

}

/*

* Copyright (c) 2011-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Sluift/sluift.h>

#include <string>

#include <boost/assign/list_of.hpp>

#include <boost/bind.hpp>

#include <boost/filesystem.hpp>

#include <boost/numeric/conversion/cast.hpp>

#include <lua.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/sleep.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/IDN/IDNConverter.h>

#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h>

#include <Swiften/Serializer/PayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/StringCodecs/Hexify.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateFactory.h>

#include <Sluift/ITunesInterface.h>

#include <Sluift/Lua/Check.h>

#include <Sluift/Lua/Debug.h>

#include <Sluift/Lua/Exception.h>

#include <Sluift/Lua/FunctionRegistration.h>

#include <Sluift/Lua/LuaUtils.h>

#include <Sluift/LuaElementConvertor.h>

#include <Sluift/SluiftClient.h>

#include <Sluift/SluiftComponent.h>

#include <Sluift/Watchdog.h>

#include <Sluift/globals.h>

using namespace Swift;

namespace Swift {

namespace Sluift {

SluiftGlobals globals;

}

// Load core lib code

if (luaL_loadbuffer(L, core_lua, core_lua_size, "core.lua") != 0) {

lua_error(L);

}

lua_pushvalue(L, -2);

lua_call(L, 1, 1);

Sluift::globals.coreLibIndex = luaL_ref(L, LUA_REGISTRYINDEX);

// Register functions

Lua::FunctionRegistry::getInstance().addFunctionsToTable(L, "Sluift");

Lua::FunctionRegistry::getInstance().createFunctionTable(L, "JID");

lua_setfield(L, -2, "jid");

Lua::FunctionRegistry::getInstance().createFunctionTable(L, "Base64");

lua_setfield(L, -2, "base64");

Lua::FunctionRegistry::getInstance().createFunctionTable(L, "IDN");

lua_setfield(L, -2, "idn");

Lua::FunctionRegistry::getInstance().createFunctionTable(L, "Crypto");

lua_setfield(L, -2, "crypto");

Lua::FunctionRegistry::getInstance().createFunctionTable(L, "FS");

lua_setfield(L, -2, "fs");

#ifdef HAVE_ITUNES

Lua::FunctionRegistry::getInstance().createFunctionTable(L, "iTunes");

lua_setfield(L, -2, "itunes");

#endif

// Register convenience functions

lua_rawgeti(L, LUA_REGISTRYINDEX, Sluift::globals.coreLibIndex);

std::vector<std::string> coreLibExports = boost::assign::list_of

("tprint")("disco")("help")("get_help")("copy")("with")("read_file")("create_form");

lua_getfield(L, -1, coreLibExport.c_str());

lua_setfield(L, -3, coreLibExport.c_str());

}

lua_pop(L, 1);

// Load client metatable

lua_rawgeti(L, LUA_REGISTRYINDEX, Sluift::globals.coreLibIndex);

std::vector<std::string> tables = boost::assign::list_of("Client");

lua_getfield(L, -1, table.c_str());

Lua::FunctionRegistry::getInstance().addFunctionsToTable(L, table);

lua_pop(L, 1);

}

lua_pop(L, 1);

// Load component metatable

lua_rawgeti(L, LUA_REGISTRYINDEX, Sluift::globals.coreLibIndex);

std::vector<std::string> comp_tables = boost::assign::list_of("Component");

lua_getfield(L, -1, table.c_str());

Lua::FunctionRegistry::getInstance().addFunctionsToTable(L, table);

lua_pop(L, 1);

}

lua_pop(L, 1);

// Register documentation for all elements

boost::optional<LuaElementConvertor::Documentation> documentation = convertor->getDocumentation();

if (documentation) {

Lua::registerClassHelp(L, documentation->className, documentation->description);

}

}

// Register global documentation

Lua::registerExtraHelp(L, -1, "sluift");

return 1;

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <SwifTools/Application/ApplicationPathProvider.h>

#include <boost/filesystem.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/Paths.h>

namespace Swift {

ApplicationPathProvider::ApplicationPathProvider(const std::string& applicationName) : applicationName(applicationName) {

}

ApplicationPathProvider::~ApplicationPathProvider() {

}

boost::filesystem::path ApplicationPathProvider::getProfileDir(const std::string& profile) const {

boost::filesystem::path result(getHomeDir() / profile);

try {

boost::filesystem::create_directory(result);

}

catch (const boost::filesystem::filesystem_error& e) {

SWIFT_LOG(error) << e.what() << std::endl;

}

return result;

}

boost::filesystem::path ApplicationPathProvider::getResourcePath(const std::string& resource) const {

std::vector<boost::filesystem::path> resourcePaths = getResourceDirs();

boost::filesystem::path r(resourcePath / resource);

if (boost::filesystem::exists(r)) {

return r;

}

}

return boost::filesystem::path();

}

boost::filesystem::path ApplicationPathProvider::getExecutableDir() const {

return Paths::getExecutablePath();

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <SwifTools/Application/UnixApplicationPathProvider.h>

#include <stdlib.h>

#include <boost/algorithm/string.hpp>

#include <unistd.h>

#include <Swiften/Base/String.h>

namespace Swift {

UnixApplicationPathProvider::UnixApplicationPathProvider(const std::string& name) : ApplicationPathProvider(name) {

resourceDirs.push_back(getExecutableDir() / "../resources"); // Development

resourceDirs.push_back(getExecutableDir() / ".." / "share" / boost::to_lower_copy(getApplicationName())); // Local install

char* xdgDataDirs = getenv("XDG_DATA_DIRS");

if (xdgDataDirs) {

std::vector<std::string> dataDirs = String::split(xdgDataDirs, ':');

if (!dataDirs.empty()) {

resourceDirs.push_back(boost::filesystem::path(dir) / "swift");

}

return;

}

}

resourceDirs.push_back("/usr/local/share/" + boost::to_lower_copy(getApplicationName()));

resourceDirs.push_back("/usr/share/" + boost::to_lower_copy(getApplicationName()));

}

boost::filesystem::path UnixApplicationPathProvider::getHomeDir() const {

char* home = getenv("HOME");

return home ? boost::filesystem::path(home) : boost::filesystem::path();

}

boost::filesystem::path UnixApplicationPathProvider::getDataDir() const {

char* xdgDataHome = getenv("XDG_DATA_HOME");

std::string dataDir;

if (xdgDataHome) {

dataDir = std::string(xdgDataHome);

}

boost::filesystem::path dataPath = (dataDir.empty() ?

getHomeDir() / ".local" / "share"

: boost::filesystem::path(dataDir)) / boost::to_lower_copy(getApplicationName());

try {

boost::filesystem::create_directories(dataPath);

}

catch (const boost::filesystem::filesystem_error& e) {

}

return dataPath;

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

// FIXME: This notifier needs finishing (handling callbacks etc.)

#include <SwifTools/Notifier/GNTPNotifier.h>

#include <cassert>

#include <iostream>

#include <sstream>

#include <boost/bind.hpp>

#include <Swiften/Base/Path.h>

#include <Swiften/Network/ConnectionFactory.h>

namespace Swift {

GNTPNotifier::GNTPNotifier(const std::string& name, const boost::filesystem::path& icon, ConnectionFactory* connectionFactory) : name(name), icon(icon), connectionFactory(connectionFactory), initialized(false), registered(false) {

// Registration message

std::ostringstream message;

message << "GNTP/1.0 REGISTER NONE\r\n";

message << "Application-Name: " << name << "\r\n";

message << "Application-Icon: file://" << pathToString(icon) << "\r\n";

message << "Notifications-Count: " << getAllTypes().size() << "\r\n";

std::vector<Notifier::Type> defaultTypes = getDefaultTypes();

std::vector<Notifier::Type> allTypes = getAllTypes();

message << "\r\n";

message << "Notification-Name: " << typeToString(type) << "\r\n";

message << "Notification-Enabled: " << (std::find(defaultTypes.begin(), defaultTypes.end(), type) == defaultTypes.end() ? "false" : "true") << "\r\n";

}

message << "\r\n";

send(message.str());

}

GNTPNotifier::~GNTPNotifier() {

}

void GNTPNotifier::send(const std::string& message) {

if (currentConnection) {

return;

}

currentMessage = message;

currentConnection = connectionFactory->createConnection();

currentConnection->onConnectFinished.connect(boost::bind(&GNTPNotifier::handleConnectFinished, this, _1));

currentConnection->onDataRead.connect(boost::bind(&GNTPNotifier::handleDataRead, this, _1));

currentConnection->connect(HostAddressPort(HostAddress("127.0.0.1"), 23053));

}

void GNTPNotifier::showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()>) {

if (registered) {

std::ostringstream message;

message << "GNTP/1.0 NOTIFY NONE\r\n";

message << "Application-Name: " << name << "\r\n";

message << "Notification-Name: " << typeToString(type) << "\r\n";

message << "Notification-Title: " << subject << "\r\n";

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <SwifTools/TabComplete.h>

#include <algorithm>

#include <boost/algorithm/string.hpp>

namespace Swift {

void TabComplete::addWord(const std::string& word) {

words_.erase(std::remove(words_.begin(), words_.end(), word), words_.end());

words_.insert(words_.begin(), word);

if (boost::starts_with(boost::to_lower_copy(word), lastShort_)) {

lastCompletionCandidates_.insert(lastCompletionCandidates_.begin(), word);

}

}

void TabComplete::removeWord(const std::string& word) {

words_.erase(std::remove(words_.begin(), words_.end(), word), words_.end());

lastCompletionCandidates_.erase(std::remove(lastCompletionCandidates_.begin(), lastCompletionCandidates_.end(), word), lastCompletionCandidates_.end());

}

std::string TabComplete::completeWord(const std::string& word) {

if (word == lastCompletion_) {

if (!lastCompletionCandidates_.empty()) {

size_t match = 0;

for (match = 0; match < lastCompletionCandidates_.size(); match++) {

if (lastCompletionCandidates_[match] == lastCompletion_) {

break;

}

}

size_t nextIndex = match + 1;

nextIndex = nextIndex >= lastCompletionCandidates_.size() ? 0 : nextIndex;

lastCompletion_ = lastCompletionCandidates_[nextIndex];

}

} else {

lastShort_ = boost::to_lower_copy(word);

lastCompletionCandidates_.clear();

if (boost::starts_with(boost::to_lower_copy(candidate), boost::to_lower_copy(word))) {

lastCompletionCandidates_.push_back(candidate);

}

}

lastCompletion_ = !lastCompletionCandidates_.empty() ? lastCompletionCandidates_[0] : word;

}

return lastCompletion_;

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/AdHocManager.h>

#include <memory>

#include <boost/bind.hpp>

#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

#include <Swiften/Queries/IQRouter.h>

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

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

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

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

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

namespace Swift {

AdHocManager::AdHocManager(const JID& jid, AdHocCommandWindowFactory* factory, IQRouter* iqRouter, UIEventStream* uiEventStream, MainWindow* mainWindow) : jid_(jid) {

iqRouter_ = iqRouter;

uiEventStream_ = uiEventStream;

mainWindow_ = mainWindow;

factory_ = factory;

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

}

AdHocManager::~AdHocManager() {

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

for (auto& controller : controllers_) {

controller->onDeleting.disconnect(boost::bind(&AdHocManager::removeController, this, controller));

}

}

void AdHocManager::removeController(std::shared_ptr<AdHocController> controller) {

controller->onDeleting.disconnect(boost::bind(&AdHocManager::removeController, this, controller));

controllers_.erase(std::find(controllers_.begin(), controllers_.end(), controller));

}

void AdHocManager::setServerDiscoInfo(std::shared_ptr<DiscoInfo> info) {

if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::CommandsFeature)) {

if (discoItemsRequest_) {

discoItemsRequest_->onResponse.disconnect(boost::bind(&AdHocManager::handleServerDiscoItemsResponse, this, _1, _2));

discoItemsRequest_.reset();

}

discoItemsRequest_ = GetDiscoItemsRequest::create(JID(jid_.getDomain()), DiscoInfo::CommandsFeature, iqRouter_);

discoItemsRequest_->onResponse.connect(boost::bind(&AdHocManager::handleServerDiscoItemsResponse, this, _1, _2));

discoItemsRequest_->send();

} else {

mainWindow_->setAvailableAdHocCommands(std::vector<DiscoItems::Item>());

}

}

void AdHocManager::setOnline(bool online) {

controller->setOnline(online);

}

}

void AdHocManager::handleServerDiscoItemsResponse(std::shared_ptr<DiscoItems> items, ErrorPayload::ref error) {

std::vector<DiscoItems::Item> commands;

if (!error) {

if (item.getNode() != "http://isode.com/xmpp/commands#test") {

commands.push_back(item);

}

}

}

mainWindow_->setAvailableAdHocCommands(commands);

}

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

std::shared_ptr<RequestAdHocUIEvent> adHocEvent = std::dynamic_pointer_cast<RequestAdHocUIEvent>(event);

if (adHocEvent) {

std::shared_ptr<OutgoingAdHocCommandSession> command = std::make_shared<OutgoingAdHocCommandSession>(adHocEvent->getCommand().getJID(), adHocEvent->getCommand().getNode(), iqRouter_);

std::shared_ptr<AdHocController> controller = std::make_shared<AdHocController>(factory_, command);

controller->onDeleting.connect(boost::bind(&AdHocManager::removeController, this, controller));

controllers_.push_back(controller);

}

std::shared_ptr<RequestAdHocWithJIDUIEvent> adHocJIDEvent = std::dynamic_pointer_cast<RequestAdHocWithJIDUIEvent>(event);

if (!!adHocJIDEvent) {

std::shared_ptr<OutgoingAdHocCommandSession> command = std::make_shared<OutgoingAdHocCommandSession>(adHocJIDEvent->getJID(), adHocJIDEvent->getNode(), iqRouter_);

std::shared_ptr<AdHocController> controller = std::make_shared<AdHocController>(factory_, command);

controller->onDeleting.connect(boost::bind(&AdHocManager::removeController, this, controller));

controllers_.push_back(controller);

}

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <vector>

#include <boost/signals2.hpp>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/AdHocController.h>

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

namespace Swift {

class IQRouter;

class MainWindow;

class UIEventStream;

class AdHocCommandWindowFactory;

class AdHocManager {

public:

AdHocManager(const JID& jid, AdHocCommandWindowFactory* factory, IQRouter* iqRouter, UIEventStream* uiEventStream, MainWindow* mainWindow);

~AdHocManager();

void removeController(std::shared_ptr<AdHocController> contoller);

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

void setOnline(bool online);

private:

void handleServerDiscoItemsResponse(std::shared_ptr<DiscoItems>, ErrorPayload::ref error);

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

boost::signals2::signal<void (const AdHocController&)> onControllerComplete;

JID jid_;

IQRouter* iqRouter_;

UIEventStream* uiEventStream_;

MainWindow* mainWindow_;

AdHocCommandWindowFactory* factory_;

GetDiscoItemsRequest::ref discoItemsRequest_;

std::vector<std::shared_ptr<AdHocController> > controllers_;

};

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2014-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/BlockListController.h>

#include <boost/bind.hpp>

#include <Swiften/Base/format.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swift/Controllers/Intl.h>

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

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

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

#include <Swift/Controllers/XMPPEvents/ErrorEvent.h>

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

namespace Swift {

BlockListController::BlockListController(ClientBlockListManager* blockListManager, UIEventStream* uiEventStream, BlockListEditorWidgetFactory* blockListEditorWidgetFactory, EventController* eventController) : blockListManager_(blockListManager), blockListEditorWidgetFactory_(blockListEditorWidgetFactory), blockListEditorWidget_(nullptr), eventController_(eventController), remainingRequests_(0), uiEventStream_(uiEventStream) {

uiEventStream->onUIEvent.connect(boost::bind(&BlockListController::handleUIEvent, this, _1));

blockListManager_->getBlockList()->onItemAdded.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

blockListManager_->getBlockList()->onItemRemoved.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

}

BlockListController::~BlockListController() {

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

blockListManager_->getBlockList()->onItemAdded.disconnect(boost::bind(&BlockListController::handleBlockListChanged, this));

blockListManager_->getBlockList()->onItemRemoved.disconnect(boost::bind(&BlockListController::handleBlockListChanged, this));

}

void BlockListController::blockListDifferences(const std::vector<JID> &newBlockList, std::vector<JID> &jidsToUnblock, std::vector<JID> &jidsToBlock) const {

if (std::find(newBlockList.begin(), newBlockList.end(), jid) == newBlockList.end()) {

jidsToUnblock.push_back(jid);

}

}

if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

jidsToBlock.push_back(jid);

}

}

}

void BlockListController::handleUIEvent(std::shared_ptr<UIEvent> rawEvent) {

// handle UI dialog

std::shared_ptr<RequestBlockListDialogUIEvent> requestDialogEvent = std::dynamic_pointer_cast<RequestBlockListDialogUIEvent>(rawEvent);

if (requestDialogEvent != nullptr) {

if (blockListEditorWidget_ == nullptr) {

blockListEditorWidget_ = blockListEditorWidgetFactory_->createBlockListEditorWidget();

blockListEditorWidget_->onSetNewBlockList.connect(boost::bind(&BlockListController::handleSetNewBlockList, this, _1));

}

blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

blockListEditorWidget_->setCurrentBlockList(blockListBeforeEdit);

blockListEditorWidget_->setError("");

blockListEditorWidget_->show();

return;

}

// handle block state change

std::shared_ptr<RequestChangeBlockStateUIEvent> changeStateEvent = std::dynamic_pointer_cast<RequestChangeBlockStateUIEvent>(rawEvent);

if (changeStateEvent != nullptr) {

if (changeStateEvent->getBlockState() == RequestChangeBlockStateUIEvent::Blocked) {

GenericRequest<BlockPayload>::ref blockRequest = blockListManager_->createBlockJIDRequest(changeStateEvent->getContact());

blockRequest->onResponse.connect(boost::bind(&BlockListController::handleBlockResponse, this, blockRequest, _1, _2, std::vector<JID>(1, changeStateEvent->getContact()), false));

blockRequest->send();

} else if (changeStateEvent->getBlockState() == RequestChangeBlockStateUIEvent::Unblocked) {

GenericRequest<UnblockPayload>::ref unblockRequest = blockListManager_->createUnblockJIDRequest(changeStateEvent->getContact());

if (!jidsToBlock.empty()) {

remainingRequests_++;

GenericRequest<BlockPayload>::ref blockRequest = blockListManager_->createBlockJIDsRequest(jidsToBlock);

blockRequest->onResponse.connect(boost::bind(&BlockListController::handleBlockResponse, this, blockRequest, _1, _2, jidsToBlock, true));

blockRequest->send();

}

if (!jidsToUnblock.empty()) {

remainingRequests_++;

GenericRequest<UnblockPayload>::ref unblockRequest = blockListManager_->createUnblockJIDsRequest(jidsToUnblock);

unblockRequest->onResponse.connect(boost::bind(&BlockListController::handleUnblockResponse, this, unblockRequest, _1, _2, jidsToUnblock, true));

unblockRequest->send();

}

if (!jidsToBlock.empty() || !jidsToUnblock.empty()) {

assert(blockListEditorWidget_);

blockListEditorWidget_->setBusy(true);

blockListEditorWidget_->setError("");

} else {

blockListEditorWidget_->hide();

}

}

void BlockListController::handleBlockListChanged() {

if (blockListEditorWidget_) {

std::vector<JID> jidsToBlock;

std::vector<JID> jidsToUnblock;

blockListDifferences(blockListEditorWidget_->getCurrentBlockList(), jidsToUnblock, jidsToBlock);

blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

blockListBeforeEdit.push_back(jid);

}

}

blockListBeforeEdit.erase(std::remove(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid), blockListBeforeEdit.end());

}

blockListEditorWidget_->setCurrentBlockList(blockListBeforeEdit);

}

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

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

#include <algorithm>

#include <boost/bind.hpp>

#include <boost/regex.hpp>

#include <boost/algorithm/string.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/Tristate.h>

#include <Swiften/Client/BlockList.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/Thread.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/MUC/MUCBookmark.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <SwifTools/TabComplete.h>

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

#include <Swift/Controllers/Highlighter.h>

#include <Swift/Controllers/Intl.h>

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

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

#include <Swift/Controllers/Roster/ItemOperations/SetAvatar.h>

#include <Swift/Controllers/Roster/ItemOperations/SetMUC.h>

#include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>

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

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

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

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

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

// Add contact is available only if the real JID is also available

if (muc_->getOccupant(item->getJID().getResource()).getRealJID()) {

actions.push_back(ChatWindow::AddContact);

}

actions.push_back(ChatWindow::ShowProfile);

}

chatWindow_->setAvailableOccupantActions(actions);

}

void MUCController::handleActionRequestedOnOccupant(ChatWindow::OccupantAction action, ContactRosterItem* item) {

JID mucJID = item->getJID();

MUCOccupant occupant = muc_->getOccupant(mucJID.getResource());

JID realJID;

if (occupant.getRealJID()) {

realJID = occupant.getRealJID().get();

}

switch (action) {

case ChatWindow::Kick: muc_->kickOccupant(mucJID);break;

case ChatWindow::Ban: muc_->changeAffiliation(realJID, MUCOccupant::Outcast);break;

case ChatWindow::MakeModerator: muc_->changeOccupantRole(mucJID, MUCOccupant::Moderator);break;

case ChatWindow::MakeParticipant: muc_->changeOccupantRole(mucJID, MUCOccupant::Participant);break;

case ChatWindow::MakeVisitor: muc_->changeOccupantRole(mucJID, MUCOccupant::Visitor);break;

case ChatWindow::AddContact: if (occupant.getRealJID()) events_->send(std::make_shared<RequestAddUserDialogUIEvent>(realJID, occupant.getNick()));break;

case ChatWindow::ShowProfile: events_->send(std::make_shared<ShowProfileForRosterItemUIEvent>(mucJID));break;

}

}

void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {

Tristate support = Yes;

bool any = false;

DiscoInfo::ref disco = entityCapsProvider_->getCaps(toJID_.toBare().toString() + "/" + nick);

if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

any = true;

} else {

support = Maybe;

}

}

if (!any) {

support = No;

}

chatWindow_->setCorrectionEnabled(support);

}

/**

* Join the MUC if not already in it.

*/

void MUCController::rejoin() {

if (parting_) {

joined_ = false;

parting_ = false;

if (password_) {

muc_->setPassword(*password_);

}

//FIXME: check for received activity

#ifdef SWIFT_EXPERIMENTAL_HISTORY

if (lastActivity_ == boost::posix_time::not_a_date_time && historyController_) {

lastActivity_ = historyController_->getLastTimeStampFromMUC(selfJID_, toJID_);

}

#endif

if (lastActivity_ == boost::posix_time::not_a_date_time) {

muc_->joinAs(nick_);

}

else {

muc_->joinWithContextSince(nick_, lastActivity_);

}

}

}

bool MUCController::isJoined() {

return joined_;

}

const std::string& MUCController::getNick() {

return nick_;

}

const boost::optional<std::string> MUCController::getPassword() const {

return password_;

}

bool MUCController::isImpromptu() const {

return isImpromptu_;

}

std::map<std::string, JID> MUCController::getParticipantJIDs() const {

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

std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();

if (occupant.first != nick_) {

participants[occupant.first] = occupant.second.getRealJID().is_initialized() ? occupant.second.getRealJID().get().toBare() : JID();

}

}

return participants;

}

void MUCController::sendInvites(const std::vector<JID>& jids, const std::string& reason) const {

muc_->invitePerson(jid, reason, isImpromptu_);

}

}

void MUCController::handleJoinTimeoutTick() {

receivedActivity();

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "Room %1% is not responding. This operation may never complete.")) % toJID_.toString())), ChatWindow::DefaultDirection);

}

void MUCController::receivedActivity() {

if (loginCheckTimer_) {

loginCheckTimer_->stop();

}

}

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wswitch-enum"

void MUCController::handleJoinFailed(std::shared_ptr<ErrorPayload> error) {

receivedActivity();

std::string errorMessage = QT_TRANSLATE_NOOP("", "Unable to enter this room");

std::string rejoinNick;

if (error) {

switch (error->getCondition()) {

case ErrorPayload::Conflict:

rejoinNick = nick_ + "_";

errorMessage = str(format(QT_TRANSLATE_NOOP("", "Unable to enter this room as %1%, retrying as %2%")) % nick_ % rejoinNick);

break;

case ErrorPayload::JIDMalformed:

errorMessage += ": ";

case JoinThenPart: break;

}

(*it).type = type;

break;

}

}

if (!matched) {

joinParts.push_back(newEvent);

}

}

std::string MUCController::concatenateListOfNames(const std::vector<NickJoinPart>& joinParts) {

std::string result;

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

if (i > 0) {

if (i < joinParts.size() - 1) {

result += ", ";

} else {

result += QT_TRANSLATE_NOOP("", " and ");

}

}

NickJoinPart event = joinParts[i];

result += event.nick;

}

return result;

}

std::string MUCController::generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu) {

std::vector<NickJoinPart> sorted[4];

std::string eventStrings[4];

sorted[event.type].push_back(event);

}

std::string result;

std::vector<JoinPart> populatedEvents;

for (size_t i = 0; i < 4; i++) {

std::string names = concatenateListOfNames(sorted[i]);

if (!names.empty()) {

std::string eventString;

switch (i) {

case Join:

if (sorted[i].size() > 1) {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have joined the chat") : QT_TRANSLATE_NOOP("", "%1% have entered the room"));

}

else {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% has joined the chat") : QT_TRANSLATE_NOOP("", "%1% has entered the room"));

}

break;

case Part:

if (sorted[i].size() > 1) {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have left the chat") : QT_TRANSLATE_NOOP("", "%1% have left the room"));

}

else {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have left the chat") : QT_TRANSLATE_NOOP("", "%1% has left the room"));

}

break;

case JoinThenPart:

if (sorted[i].size() > 1) {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have joined then left the chat") : QT_TRANSLATE_NOOP("", "%1% have entered then left the room"));

}

else {

if (i > 0) {

if (i < populatedEvents.size() - 1) {

result += ", ";

} else {

result += QT_TRANSLATE_NOOP("", " and ");

}

}

result += eventStrings[populatedEvents[i]];

}

return result;

}

std::string MUCController::generateNicknameChangeString(const std::string& oldNickname, const std::string& newNickname) {

return str(boost::format(QT_TRANSLATE_NOOP("", "%1% is now known as %2%.")) % oldNickname % newNickname);

}

void MUCController::handleChangeSubjectRequest(const std::string& subject) {

muc_->changeSubject(subject);

}

void MUCController::handleBookmarkRequest() {

const JID jid = muc_->getJID();

// Prepare new bookmark for this room.

MUCBookmark roomBookmark(jid, jid.toBare().toString());

roomBookmark.setPassword(password_);

roomBookmark.setNick(nick_);

// Check for existing bookmark for this room and, if it exists, use it instead.

std::vector<MUCBookmark> bookmarks = mucBookmarkManager_->getBookmarks();

if (bookmark.getRoom() == jid.toBare()) {

roomBookmark = bookmark;

break;

}

}

chatWindow_->showBookmarkWindow(roomBookmark);

}

void MUCController::handleConfigureRequest(Form::ref form) {

if (form) {

muc_->configureRoom(form);

}

else {

muc_->requestConfigurationForm();

}

}

void MUCController::handleConfigurationFailed(ErrorPayload::ref error) {

std::string errorMessage = getErrorMessage(error);

errorMessage = str(format(QT_TRANSLATE_NOOP("", "Room configuration failed: %1%.")) % errorMessage);

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

}

void MUCController::handleOccupantRoleChangeFailed(ErrorPayload::ref error, const JID&, MUCOccupant::Role) {

std::string errorMessage = getErrorMessage(error);

errorMessage = str(format(QT_TRANSLATE_NOOP("", "Occupant role change failed: %1%.")) % errorMessage);

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

}

onImpromptuConfigCompleted();

}

void MUCController::handleConfigurationFormReceived(Form::ref form) {

if (isImpromptu_) {

if (!isImpromptuAlreadyConfigured_) {

configureAsImpromptuRoom(form);

}

} else {

chatWindow_->showRoomConfigurationForm(form);

}

}

void MUCController::handleConfigurationCancelled() {

muc_->cancelConfigureRoom();

}

void MUCController::handleDestroyRoomRequest() {

muc_->destroyRoom();

}

void MUCController::handleInvitePersonToThisMUCRequest(const std::vector<JID>& jidsToInvite) {

RequestInviteToMUCUIEvent::ImpromptuMode mode = isImpromptu_ ? RequestInviteToMUCUIEvent::Impromptu : RequestInviteToMUCUIEvent::NotImpromptu;

std::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(muc_->getJID(), jidsToInvite, mode));

eventStream_->send(event);

}

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

std::shared_ptr<InviteToMUCUIEvent> inviteEvent = std::dynamic_pointer_cast<InviteToMUCUIEvent>(event);

if (inviteEvent && inviteEvent->getRoom() == muc_->getJID()) {

muc_->invitePerson(jid, inviteEvent->getReason(), isImpromptu_);

}

}

}

void MUCController::handleGetAffiliationsRequest() {

muc_->requestAffiliationList(MUCOccupant::Owner);

muc_->requestAffiliationList(MUCOccupant::Admin);

muc_->requestAffiliationList(MUCOccupant::Member);

muc_->requestAffiliationList(MUCOccupant::Outcast);

}

void MUCController::handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes) {

std::set<JID> addedJIDs;

if (change.first != MUCOccupant::NoAffiliation) {

addedJIDs.insert(change.second);

}

}

if (change.first != MUCOccupant::NoAffiliation || addedJIDs.find(change.second) == addedJIDs.end()) {

muc_->changeAffiliation(change.second, change.first);

}

}

}

void MUCController::handleUnblockUserRequest() {

eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, muc_->getJID()));

}

void MUCController::handleBlockingStateChanged() {

std::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

if (blockList->getState() == BlockList::Available) {

if (blockList->isBlocked(toJID_)) {

if (!blockedContactAlert_) {

blockedContactAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "You've blocked this room. To enter the room, first unblock it using the cog menu and try again"));

}

chatWindow_->setBlockingState(ChatWindow::IsBlocked);

} else {

if (blockedContactAlert_) {

chatWindow_->removeAlert(*blockedContactAlert_);

blockedContactAlert_.reset();

}

chatWindow_->setBlockingState(ChatWindow::IsUnblocked);

}

}

}

void MUCController::handleAffiliationListReceived(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids) {

chatWindow_->setAffiliations(affiliation, jids);

}

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

// log only incoming messages

if (isIncoming && historyController_) {

historyController_->addMessage(message, fromJID, toJID, HistoryMessage::Groupchat, timeStamp);

}

}

void MUCController::addRecentLogs() {

if (!historyController_) {

return;

}

joinContext_ = historyController_->getMUCContext(selfJID_, toJID_, lastActivity_);

bool senderIsSelf = nick_ == message.getFromJID().getResource();

// the chatWindow uses utc timestamps

addMessage(chatMessageParser_->parseMessageBody(message.getMessage()), senderDisplayNameFromMessage(message.getFromJID()), senderIsSelf, std::make_shared<SecurityLabel>(), avatarManager_->getAvatarPath(message.getFromJID()), message.getTime() - boost::posix_time::hours(message.getOffset()));

}

}

void MUCController::checkDuplicates(std::shared_ptr<Message> newMessage) {

std::string body = newMessage->getBody().get_value_or("");

JID jid = newMessage->getFrom();

boost::optional<boost::posix_time::ptime> time = newMessage->getTimestamp();

boost::posix_time::ptime messageTime = message.getTime() - boost::posix_time::hours(message.getOffset());

if (time && time < messageTime) {

break;

}

if (time && time != messageTime) {

continue;

}

if (message.getFromJID() != jid) {

continue;

}

if (message.getMessage() != body) {

continue;

}

// Mark the message as unreadable

newMessage->setBody("");

}

}

void MUCController::setNick(const std::string& nick) {

nick_ = nick;

highlighter_->setNick(nick_);

}

Form::ref MUCController::buildImpromptuRoomConfiguration(Form::ref roomConfigurationForm) {

Form::ref result = std::make_shared<Form>(Form::SubmitType);

std::string impromptuConfigs[] = { "muc#roomconfig_enablelogging", "muc#roomconfig_persistentroom", "muc#roomconfig_publicroom", "muc#roomconfig_whois"};

std::set<std::string> impromptuConfigsMissing(impromptuConfigs, impromptuConfigs + 4);

std::shared_ptr<FormField> resultField;

if (field->getName() == "muc#roomconfig_enablelogging") {

resultField = std::make_shared<FormField>(FormField::BooleanType, "0");

}

if (field->getName() == "muc#roomconfig_persistentroom") {

resultField = std::make_shared<FormField>(FormField::BooleanType, "0");

}

if (field->getName() == "muc#roomconfig_publicroom") {

resultField = std::make_shared<FormField>(FormField::BooleanType, "0");

}

if (field->getName() == "muc#roomconfig_whois") {

resultField = std::make_shared<FormField>(FormField::ListSingleType, "anyone");

}

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

resultField = std::make_shared<FormField>(FormField::HiddenType, "http://jabber.org/protocol/muc#roomconfig");

}

if (resultField) {

impromptuConfigsMissing.erase(field->getName());

resultField->setName(field->getName());

result->addField(resultField);

}

}

if (config == "muc#roomconfig_publicroom") {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "This server doesn't support hiding your chat from other users.")), ChatWindow::DefaultDirection);

} else if (config == "muc#roomconfig_whois") {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "This server doesn't support sharing people's real identity in this chat.")), ChatWindow::DefaultDirection);

}

}

return result;

}

void MUCController::setImpromptuWindowTitle() {

std::string title;

std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();

if (occupants.size() <= 1) {

title = QT_TRANSLATE_NOOP("", "Empty Chat");

} else {

if (pair.first != nick_) {

title += (title.empty() ? "" : ", ") + pair.first;

}

}

}

chatWindow_->setName(title);

}

void MUCController::handleRoomUnlocked() {

// Handle buggy MUC implementations where the joined room already exists and is unlocked.

// Configure the room again in this case.

if (!isImpromptuAlreadyConfigured_) {

if (isImpromptu_ && (muc_->getOccupant(nick_).getAffiliation() == MUCOccupant::Owner)) {

muc_->requestConfigurationForm();

} else if (isImpromptu_) {

onImpromptuConfigCompleted();

}

}

}

void MUCController::setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) {

ChatControllerBase::setAvailableServerFeatures(info);

if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::BlockingCommandFeature)) {

std::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

blockingOnStateChangedConnection_ = blockList->onStateChanged.connect(boost::bind(&MUCController::handleBlockingStateChanged, this));

blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&MUCController::handleBlockingStateChanged, this));

blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&MUCController::handleBlockingStateChanged, this));

handleBlockingStateChanged();

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

#include <Swift/Controllers/WhiteboardManager.h>

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

using namespace Swift;

class ChatsManagerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(ChatsManagerTest);

CPPUNIT_TEST(testFirstOpenWindowIncoming);

CPPUNIT_TEST(testSecondOpenWindowIncoming);

CPPUNIT_TEST(testFirstOpenWindowOutgoing);

CPPUNIT_TEST(testFirstOpenWindowBareToFull);

CPPUNIT_TEST(testSecondWindow);

CPPUNIT_TEST(testUnbindRebind);

CPPUNIT_TEST(testNoDuplicateUnbind);

CPPUNIT_TEST(testThreeMUCWindows);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnRemoveFromRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnAddToRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnMessageAndNotReceipt);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnTypingAndNotActive);

CPPUNIT_TEST(testChatControllerPMPresenceHandling);

CPPUNIT_TEST(testLocalMUCServiceDiscoveryResetOnDisconnect);

CPPUNIT_TEST(testPresenceChangeDoesNotReplaceMUCInvite);

// Highlighting tests

CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

CPPUNIT_TEST(testChatControllerMeMessageHandling);

CPPUNIT_TEST(testChatControllerMeMessageHandlingInMUC);

// Carbons tests

CPPUNIT_TEST(testCarbonsForwardedIncomingMessageToSecondResource);

CPPUNIT_TEST(testCarbonsForwardedOutgoingMessageFromSecondResource);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

mocks_ = new MockRepository();

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

stanzaChannel_ = new DummyStanzaChannel();

iqRouter_ = new IQRouter(stanzaChannel_);

eventController_ = new EventController();

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

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

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

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

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

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

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

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

uiEventStream_ = new UIEventStream();

entityCapsProvider_ = new DummyEntityCapsProvider();

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

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

settings_ = new DummySettingsProvider();

/**

* Test that ChatController sends receipts if requested after change from subscription state To to subscription state Both.

*/

void testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth() {

testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::To, RosterItemPayload::Both);

}

/**

* Test that ChatController sends receipts if requested after change from subscription state To to subscription state From.

*/

void testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom() {

testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::To, RosterItemPayload::From);

}

void testChatControllerFullJIDBindingOnMessageAndNotReceipt() {

JID ownJID("test@test.com/resource");

JID sender("foo@test.com");

std::vector<JID> senderResource;

senderResource.push_back(sender.withResource("resourceA"));

senderResource.push_back(sender.withResource("resourceB"));

// We support delivery receipts.

settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

// Open chat window to a sender.

MockChatWindow* window = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(sender, uiEventStream_).Return(window);

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

// The sender supports delivery receipts.

DiscoInfo::ref disco = std::make_shared<DiscoInfo>();

disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

entityCapsProvider_->caps[senderJID] = disco;

// The sender is online.

Presence::ref senderPresence = std::make_shared<Presence>();

senderPresence->setFrom(senderJID);

senderPresence->setTo(ownJID);

stanzaChannel_->onPresenceReceived(senderPresence);

entityCapsProvider_->onCapsChanged(senderJID);

}

// Send first message.

window->onSendMessageRequest("hello there", false);

// A bare message is send because no resources is bound.

CPPUNIT_ASSERT_EQUAL(sender, stanzaChannel_->getStanzaAtIndex<Message>(1)->getTo());

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

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

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

std::shared_ptr<DeliveryReceipt> receipt = std::make_shared<DeliveryReceipt>();

receipt->setReceivedID(stanzaChannel_->getStanzaAtIndex<Message>(1)->getID());

receiptReply->addPayload(receipt);

manager_->handleIncomingMessage(receiptReply);

}

// Send second message.

window->onSendMessageRequest("how are you?", false);

// A bare message is send because no resources is bound.

CPPUNIT_ASSERT_EQUAL(sender, stanzaChannel_->getStanzaAtIndex<Message>(1)->getTo());

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

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

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

std::shared_ptr<DeliveryReceipt> receipt = std::make_shared<DeliveryReceipt>();

receipt->setReceivedID(stanzaChannel_->getStanzaAtIndex<Message>(1)->getID());

receiptReply->addPayload(receipt);

manager_->handleIncomingMessage(receiptReply);

}

// Reply with a message including a body text.

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

reply->setFrom(senderResource[0]);

reply->setTo(ownJID);

reply->setBody("fine.");

manager_->handleIncomingMessage(reply);

// Send third message.

window->onSendMessageRequest("great to hear.", false);

// The chat session is bound to the full JID of the first resource.

CPPUNIT_ASSERT_EQUAL(senderResource[0], stanzaChannel_->getStanzaAtIndex<Message>(3)->getTo());

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(2)->getPayload<DeliveryReceiptRequest>());

// Receive random receipt from second sender resource.

reply = std::make_shared<Message>();

reply->setFrom(senderResource[1]);

reply->setTo(ownJID);

std::shared_ptr<DeliveryReceipt> receipt = std::make_shared<DeliveryReceipt>();

reply = std::make_shared<Message>();

reply->setFrom(senderResource[1]);

reply->setTo(ownJID);

reply->setBody("nothing.");

manager_->handleIncomingMessage(reply);

// Send fifth message.

window->onSendMessageRequest("okay", false);

// The chat session is now bound to the full JID of the second resource.

CPPUNIT_ASSERT_EQUAL(senderResource[1], stanzaChannel_->getStanzaAtIndex<Message>(5)->getTo());

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(5)->getPayload<DeliveryReceiptRequest>());

}

void testChatControllerFullJIDBindingOnTypingAndNotActive() {

JID ownJID("test@test.com/resource");

JID sender("foo@test.com");

std::vector<JID> senderResource;

senderResource.push_back(sender.withResource("resourceA"));

senderResource.push_back(sender.withResource("resourceB"));

// We support delivery receipts.

settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

// Open chat window to a sender.

MockChatWindow* window = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(sender, uiEventStream_).Return(window);

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

// The sender supports delivery receipts.

DiscoInfo::ref disco = std::make_shared<DiscoInfo>();

disco->addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

entityCapsProvider_->caps[senderJID] = disco;

// The sender is online.

Presence::ref senderPresence = std::make_shared<Presence>();

senderPresence->setFrom(senderJID);

senderPresence->setTo(ownJID);

stanzaChannel_->onPresenceReceived(senderPresence);

entityCapsProvider_->onCapsChanged(senderJID);

}

// Send first message.

window->onSendMessageRequest("hello there", false);

// A bare message is send because no resources is bound.

CPPUNIT_ASSERT_EQUAL(sender, stanzaChannel_->getStanzaAtIndex<Message>(1)->getTo());

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

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

reply->setFrom(senderJID);

reply->setTo(ownJID);

std::shared_ptr<ChatState> csn = std::make_shared<ChatState>();

csn->setChatState(ChatState::Active);

reply->addPayload(csn);

manager_->handleIncomingMessage(reply);

}

// Send second message.

window->onSendMessageRequest("how are you?", false);

// A bare message is send because no resources is bound.

CPPUNIT_ASSERT_EQUAL(sender, stanzaChannel_->getStanzaAtIndex<Message>(1)->getTo());

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(1)->getPayload<DeliveryReceiptRequest>());

// Two resources respond with message receipts.

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

receiptReply->setFrom(senderJID);

receiptReply->setTo(ownJID);

std::shared_ptr<DeliveryReceipt> receipt = std::make_shared<DeliveryReceipt>();

receipt->setReceivedID(stanzaChannel_->getStanzaAtIndex<Message>(1)->getID());

receiptReply->addPayload(receipt);

manager_->handleIncomingMessage(receiptReply);

}

// Reply with a message including a CSN.

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

reply->setFrom(senderResource[0]);

reply->setTo(ownJID);

std::shared_ptr<ChatState> csn = std::make_shared<ChatState>();

csn->setChatState(ChatState::Composing);

reply->addPayload(csn);

manager_->handleIncomingMessage(reply);

// Send third message.

window->onSendMessageRequest("great to hear.", false);

// The chat session is now bound to the full JID of the first resource due to its recent composing message.

CPPUNIT_ASSERT_EQUAL(senderResource[0], stanzaChannel_->getStanzaAtIndex<Message>(3)->getTo());

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(3)->getPayload<DeliveryReceiptRequest>());

// Reply with a message including a CSN from the other resource.

reply = std::make_shared<Message>();

reply->setFrom(senderResource[1]);

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/algorithm/string.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.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/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/Disco/DummyEntityCapsProvider.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/Elements/Thread.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swiften/MUC/UnitTest/MockMUC.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Presence/DirectedPresenceSender.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Presence/StanzaChannelPresenceSender.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/ChatMessageParser.h>

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

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

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

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

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

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

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

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

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

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

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

}

void testJoinPartStringContructionMixed() {

std::vector<NickJoinPart> list;

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

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

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

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

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

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

}

JID jidFromOccupant(const MUCOccupant& occupant) {

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

}

void 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 */

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

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

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

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

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

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

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

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

testRoleAffiliationStatesVerify(occupants);

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

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

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

testRoleAffiliationStatesVerify(occupants);

}

}

void testSubjectChangeCorrect() {

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

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

CPPUNIT_ASSERT(message);

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

/*

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

*/

void testSubjectChangeIncorrectC() {

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

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

CPPUNIT_ASSERT(message);

CPPUNIT_ASSERT_EQUAL(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("New Room Subject");

message->setBody("");

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

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

}

}

void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {

/* verify that the roster is in sync */

GroupRosterItem* group = window_->getRosterModel()->getRoot();

GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);

CPPUNIT_ASSERT(child);

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

CPPUNIT_ASSERT(item);

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

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

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

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

}

}

}

private:

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

/*

* Copyright (c) 2010-2016 Isode Limited.

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

namespace Swift {

static const std::string SEARCHED_DIRECTORIES = "searchedDirectories";

UserSearchController::UserSearchController(Type type, const JID& jid, UIEventStream* uiEventStream, VCardManager* vcardManager, UserSearchWindowFactory* factory, IQRouter* iqRouter, RosterController* rosterController, ContactSuggester* contactSuggester, AvatarManager* avatarManager, PresenceOracle* presenceOracle, ProfileSettingsProvider* settings) : type_(type), jid_(jid), uiEventStream_(uiEventStream), vcardManager_(vcardManager), factory_(factory), iqRouter_(iqRouter), rosterController_(rosterController), contactSuggester_(contactSuggester), avatarManager_(avatarManager), presenceOracle_(presenceOracle), settings_(settings) {

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

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

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

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

window_ = nullptr;

discoWalker_ = nullptr;

loadSavedDirectories();

window_->setRoomJID(inviteToMUCRequest->getRoom());

}

return;

}

}

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

window_->setSearchError(false);

window_->setServerSupportsSearch(true);

//Abort a previous search if is active

endDiscoWalker();

delete discoWalker_;

discoWalker_ = new DiscoServiceWalker(service, iqRouter_);

discoWalker_->onServiceFound.connect(boost::bind(&UserSearchController::handleDiscoServiceFound, this, _1, _2));

discoWalker_->onWalkComplete.connect(boost::bind(&UserSearchController::handleDiscoWalkFinished, this));

discoWalker_->beginWalk();

}

void UserSearchController::endDiscoWalker() {

if (discoWalker_) {

discoWalker_->endWalk();

discoWalker_->onServiceFound.disconnect(boost::bind(&UserSearchController::handleDiscoServiceFound, this, _1, _2));

discoWalker_->onWalkComplete.disconnect(boost::bind(&UserSearchController::handleDiscoWalkFinished, this));

}

}

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

//bool isUserDirectory = false;

bool supports55 = false;

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

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

//isUserDirectory = true;

}

}

std::vector<std::string> features = info->getFeatures();

supports55 = std::find(features.begin(), features.end(), DiscoInfo::JabberSearchFeature) != features.end();

if (/*isUserDirectory && */supports55) { //FIXME: once M-Link correctly advertises directoryness.

/* Abort further searches.*/

endDiscoWalker();

std::shared_ptr<GenericRequest<SearchPayload> > searchRequest(new GenericRequest<SearchPayload>(IQ::Get, jid, std::make_shared<SearchPayload>(), iqRouter_));

searchRequest->onResponse.connect(boost::bind(&UserSearchController::handleFormResponse, this, _1, _2));

searchRequest->send();

}

}

void UserSearchController::handleFormResponse(std::shared_ptr<SearchPayload> fields, ErrorPayload::ref error) {

if (error || !fields) {

window_->setServerSupportsSearch(false);

return;

}

window_->setSearchFields(fields);

}

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

addToSavedDirectories(jid);

std::shared_ptr<GenericRequest<SearchPayload> > searchRequest(new GenericRequest<SearchPayload>(IQ::Set, jid, fields, iqRouter_));

searchRequest->onResponse.connect(boost::bind(&UserSearchController::handleSearchResponse, this, _1, _2));

searchRequest->send();

}

void UserSearchController::handleSearchResponse(std::shared_ptr<SearchPayload> resultsPayload, ErrorPayload::ref error) {

if (error || !resultsPayload) {

window_->setSearchError(true);

return;

}

std::vector<UserSearchResult> results;

if (resultsPayload->getForm()) {

window_->setResultsForm(resultsPayload->getForm());

} else {

JID jid(item.jid);

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

fields["first"] = item.first;

fields["last"] = item.last;

fields["nick"] = item.nick;

fields["email"] = item.email;

UserSearchResult result(jid, fields);

results.push_back(result);

}

window_->setResults(results);

}

}

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

suggestionsJID_= jid;

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

if (vcard) {

handleVCardChanged(jid, vcard);

}

}

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

if (jid.isValid()) {

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;

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

found = true;

break;

}

}

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

if (type_ == AddContact) {

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

}

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

if (window_) {

std::vector<Contact::ref> updates;

updates.push_back(convertJIDtoContact(jid));

}

window_->updateContacts(updates);

}

}

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

std::vector<Contact::ref> contacts;

contacts.push_back(convertJIDtoContact(jid));

}

window_->addContacts(contacts);

}

Contact::ref UserSearchController::convertJIDtoContact(const JID& jid) {

Contact::ref contact = std::make_shared<Contact>();

contact->jid = jid;

// name lookup

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

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

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;

}

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

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

if(!stringItem.empty()) {

savedDirectories_.push_back(JID(stringItem));

}

}

}

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

if (!jid.isValid()) {

return;

}

savedDirectories_.erase(std::remove(savedDirectories_.begin(), savedDirectories_.end(), jid), savedDirectories_.end());

savedDirectories_.insert(savedDirectories_.begin(), jid);

std::string collapsed;

int i = 0;

if (i >= 15) {

break;

}

if (!collapsed.empty()) {

collapsed += "\n";

}

collapsed += jidItem.toString();

++i;

}

settings_->storeString(SEARCHED_DIRECTORIES, collapsed);

window_->addSavedServices(savedDirectories_);

}

}

/*

* Copyright (c) 2011-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/ChatMessageSummarizer.h>

#include <Swiften/Base/format.h>

#include <Swift/Controllers/Intl.h>

using namespace Swift;

using namespace std;

string ChatMessageSummarizer::getSummary(const string& current, const vector<UnreadPair>& unreads) {

vector<UnreadPair> others;

int currentUnread = 0;

int otherCount = 0;

if (unread.first == current) {

currentUnread += unread.second;

} else {

if (unread.second > 0) {

otherCount += unread.second;

others.push_back(unread);

}

}

}

string myString(current);

if (currentUnread > 0) {

string result(QT_TRANSLATE_NOOP("", "%1% (%2%)"));

myString = str(format(result) % current % currentUnread);

}

if (others.size() > 1) {

string result(QT_TRANSLATE_NOOP("", "%1% and %2% others (%3%)"));

myString = str(format(result) % myString % others.size() % otherCount);

} else if (!others.empty()) {

string result(QT_TRANSLATE_NOOP("", "%1%; %2% (%3%)"));

myString = str(format(result) % myString % others[0].first % otherCount);

}

return myString;

}

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2014-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/ContactSuggester.h>

#include <algorithm>

#include <set>

#include <vector>

#include <boost/algorithm/string.hpp>

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

#include <boost/bind.hpp>

#include <boost/lambda/bind.hpp>

#include <boost/lambda/lambda.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/ContactProvider.h>

namespace lambda = boost::lambda;

namespace Swift {

ContactSuggester::ContactSuggester() {

}

ContactSuggester::~ContactSuggester() {

}

void ContactSuggester::addContactProvider(ContactProvider* provider) {

contactProviders_.push_back(provider);

}

bool ContactSuggester::matchContact(const std::string& search, const Contact::ref& c) {

if (fuzzyMatch(c->name, search)) {

return true;

}

else if (c->jid.isValid()) {

return fuzzyMatch(c->jid.toString(), search);

}

return false;

}

std::vector<Contact::ref> ContactSuggester::getSuggestions(const std::string& search, bool withMUCNicks) const {

std::vector<Contact::ref> results;

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

}

std::sort(results.begin(), results.end(), Contact::lexicographicalSortPredicate);

results.erase(std::unique(results.begin(), results.end(), Contact::equalityPredicate), results.end());

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

results.end());

std::sort(results.begin(), results.end(), boost::bind(&Contact::sortPredicate, _1, _2, search));

return results;

}

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

std::string lowerText = text;

boost::algorithm::to_lower(lowerText);

std::string lowerMatch = match;

boost::algorithm::to_lower(lowerMatch);

size_t lastMatch = 0;

for (char i : lowerMatch) {

size_t where = lowerText.find_first_of(i, lastMatch);

if (where == std::string::npos) {

return false;

}

lastMatch = where + 1;

}

return true;

}

}