libtransport.git Changeset - efd60bd374ad

Changeset - efd60bd374ad

Parent rev.

Child rev.

[Not reviewed]

0 4 0

Jan Kaluza - 10 years ago 2016-01-28 19:47:25
jkaluza@redhat.com

Slack: Add generic SlackAPI::createChannel to create slack channel and invite transport bot to it.

4 files changed with 46 insertions and 64 deletions:

spectrum/src/frontends/slack/SlackAPI.cpp

spectrum/src/frontends/slack/SlackAPI.h

spectrum/src/frontends/slack/SlackSession.cpp

spectrum/src/frontends/slack/SlackSession.h

0 comments (0 inline, 0 general)

spectrum/src/frontends/slack/SlackAPI.cpp

➞

Show inline comments

+		}
+	}
 	GET_ARRAY(resp, bots);
 	for (int i = 0; i < bots.Size(); i++) {
 		if (!bots[i].IsObject()) {
 			continue;
+		}
 		SlackUserInfo info;
 		STORE_STRING(bots[i], id);
 		info.id = id;
 		STORE_STRING(bots[i], name);
 		info.name = name;
 		info.isPrimaryOwner = 0;
 		ret[info.id] = info;
 		LOG4CXX_INFO(logger, info.id << " " << info.name);
+	}
 	return;
+}
 std::string SlackAPI::SlackObjectToPlainText(const std::string &object, bool isChannel, bool returnName) {
 	std::string ret = object;
 	if (isChannel) {
 		if (ret[0] == '<') {
 			ret = ret.substr(2, ret.size() - 3);
+		}
 	} else {
 		if (ret[0] == '<') {
 			ret = ret.substr(1, ret.size() - 2);
 			if (returnName) {
 				ret = ret.substr(0, ret.find("|"));
+			}
 			else {
 				ret = ret.substr(ret.find("|") + 1);
+			}
+		}
+	}
 	return ret;
+}
 void SlackAPI::handleSlackChannelInvite(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, const std::string &channel, const std::string &user, CreateChannelCallback callback) {
 	callback(channel);
+}
 void SlackAPI::handleSlackChannelCreate(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, const std::string &channel, const std::string &user, CreateChannelCallback callback) {
 	std::string channelId = getChannelId(req, ok, resp, data);
 	if (channelId.empty()) {
 		LOG4CXX_INFO(logger, "Error creating channel " << channel << ".");
 		return;
+	}
 	channelsInvite(channelId, user, boost::bind(&SlackAPI::handleSlackChannelInvite, this, _1, _2, _3, _4, channelId, user, callback));
+}
 void SlackAPI::handleSlackChannelList(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, const std::string &channel, const std::string &user, CreateChannelCallback callback) {
 	std::map<std::string, SlackChannelInfo> channels;
 	SlackAPI::getSlackChannelInfo(req, ok, resp, data, channels);
 	if (channels.find(channel) != channels.end()) {
 		channelsInvite(channel, user, boost::bind(&SlackAPI::handleSlackChannelInvite, this, _1, _2, _3, _4, channels[channel].id, user, callback));
+	}
 	else {
 		channelsCreate(channel, boost::bind(&SlackAPI::handleSlackChannelCreate, this, _1, _2, _3, _4, channel, user, callback));
+	}
+}
 void SlackAPI::createChannel(const std::string &channel, const std::string &user, CreateChannelCallback callback) {
 	channelsList(boost::bind(&SlackAPI::handleSlackChannelList, this, _1, _2, _3, _4, channel, user, callback));
+}
+}

spectrum/src/frontends/slack/SlackAPI.h

➞

Show inline comments

@@ @@ -46,57 +46,65 @@ class SlackChannelInfo { @@
 		std::vector<std::string> members;
 };
 class SlackImInfo {
 	public:
 		SlackImInfo() {}
 		virtual ~SlackImInfo() {}
 		std::string id;
 		std::string user;
 };
 class SlackUserInfo {
 	public:
 		SlackUserInfo() : isPrimaryOwner(false) {}
 		virtual ~SlackUserInfo() {}
 		std::string id;
 		std::string name;
 		bool isPrimaryOwner;
 };
 class SlackAPI : public HTTPRequestQueue {
 	public:
 		SlackAPI(Component *component, const std::string &token);
 		virtual ~SlackAPI();
 		void usersList(HTTPRequest::Callback callback);
 		std::string getOwnerId(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data);
 		void channelsCreate(const std::string &name, HTTPRequest::Callback callback);
 		void channelsInvite(const std::string &channel, const std::string &user, HTTPRequest::Callback callback);
 		void channelsList(HTTPRequest::Callback callback);
 		void imOpen(const std::string &uid, HTTPRequest::Callback callback);
 		std::string getChannelId(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data);
 		void deleteMessage(const std::string &channel, const std::string &ts);
 		void sendMessage(const std::string &from, const std::string &to, const std::string &text);
 		void setPurpose(const std::string &channel, const std::string &purpose);
 		static void getSlackChannelInfo(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, std::map<std::string, SlackChannelInfo> &channels);
 		static void getSlackImInfo(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, std::map<std::string, SlackImInfo> &ims);
 		static void getSlackUserInfo(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, std::map<std::string, SlackUserInfo> &users);
 		static std::string SlackObjectToPlainText(const std::string &object, bool isChannel = false, bool returnName = false);
 		// Creates channel if it does not exist and invites the user to the channel.
 		typedef boost::function< void (const std::string &channelId) > CreateChannelCallback;
 		void createChannel(const std::string &channel, const std::string &user, CreateChannelCallback callback);
 	private:
 		void handleSendMessage(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data);
 		void handleSlackChannelCreate(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, const std::string &channel, const std::string &user, CreateChannelCallback callback);
 		void handleSlackChannelList(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, const std::string &channel, const std::string &user, CreateChannelCallback callback);
 		void handleSlackChannelInvite(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, const std::string &channel, const std::string &user, CreateChannelCallback callback);
 	private:
 		Component *m_component;
 		std::string m_token;
 };
+}

spectrum/src/frontends/slack/SlackSession.cpp

➞

Show inline comments

 	if (m_user) {
 		std::map<std::string, Conversation *> convs = m_user->getConversationManager()->getConversations();
 		for (std::map<std::string, Conversation *> ::const_iterator it = convs.begin(); it != convs.end(); it++) {
 			Conversation *conv = it->second;
 			if (!conv) {
 				continue;
+			}
 			if (conv->getNickname() == message->getFrom().getResource()) {
 				return;
+			}
+		}
+	}
 	std::string from = message->getFrom().getResource();
 	std::string channel = m_jid2channel[message->getFrom().toBare().toString()];
 	LOG4CXX_INFO(logger, "JID is " << message->getFrom().toBare().toString() << " channel is " << channel);
 	if (channel.empty()) {
 		if (m_slackChannel.empty()) {
 			LOG4CXX_ERROR(logger, m_uinfo.jid << ": Received message for unknown channel from " << message->getFrom().toBare().toString());
 			return;
+		}
 		channel = m_slackChannel;
 		from = Buddy::JIDToLegacyName(message->getFrom(), m_user);
 		Buddy *b;
 		if (m_user && (b = m_user->getRosterManager()->getBuddy(from)) != NULL) {
 			from = b->getAlias() + " (" + from + ")";
+		}
+	}
 	LOG4CXX_INFO(logger, "FROM " << from);
 	m_rtm->getAPI()->sendMessage(from, channel, message->getBody());
+}
 void SlackSession::setPurpose(const std::string &purpose, const std::string &channel) {
 	std::string ch = channel;
 	if (ch.empty()) {
 		ch = m_slackChannel;
+	}
 	if (ch.empty()) {
 		return;
+	}
 	LOG4CXX_INFO(logger, "Setting channel purppose: " << ch << " " << purpose);
 	m_api->setPurpose(ch, purpose);
+}
 void SlackSession::joinRoom(std::vector<std::string> args) {
 void SlackSession::handleJoinRoomCreated(const std::string &channelId, std::vector<std::string> args) {
 	args[5] = channelId;
 	std::string &name = args[2];
 	std::string &legacyRoom = args[3];
 	std::string &legacyServer = args[4];
 	std::string &slackChannel = args[5];
 	std::string to = legacyRoom + "%" + legacyServer + "@" + m_component->getJID().toString();
 	if (!CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "registration.needRegistration", true)) {
 		m_uinfo.uin = name;
 		m_storageBackend->setUser(m_uinfo);
+	}
 // 	else {
 // 		to =  legacyRoom + "\\40" + legacyServer + "@" + m_component->getJID().toString();
 // 	}
 	m_jid2channel[to] = slackChannel;
 	m_channel2jid[slackChannel] = to;
 	Swift::Presence::ref presence = Swift::Presence::create();
 	presence->setFrom(Swift::JID("", m_uinfo.jid, "default"));
 	presence->setTo(Swift::JID(to + "/" + name));
 	presence->setType(Swift::Presence::Available);
 	presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 	m_component->getFrontend()->onPresenceReceived(presence);
 	m_onlineBuddiesTimer->start();
+}
 void SlackSession::handleJoinRoomCreate(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, std::vector<std::string> args) {
 	std::string channelId = m_api->getChannelId(req, ok, resp, data);
 	if (channelId.empty()) {
 		LOG4CXX_INFO(logger, args[1] << ": Error creating channel " << args[5] << ".");
 		return;
+	}
 	args[5] = channelId;
 	joinRoom(args);
+}
 void SlackSession::handleJoinRoomList(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, std::vector<std::string> args) {
 	std::map<std::string, SlackChannelInfo> channels;
 	SlackAPI::getSlackChannelInfo(req, ok, resp, data, channels);
 	if (channels.find(args[5]) != channels.end()) {
 		LOG4CXX_INFO(logger, args[1] << ": Channel " << args[5] << " already exists. Joining the room.");
 		args[5] = channels[args[5]].id;
 		joinRoom(args);
+	}
 	else {
 		LOG4CXX_INFO(logger, args[1] << ": Channel " << args[5] << " does not exit. Creating it.");
 		m_api->channelsCreate(args[5], boost::bind(&SlackSession::handleJoinRoomCreate, this, _1, _2, _3, _4, args));
+	}
+}
 void SlackSession::handleJoinMessage(const std::string &message, std::vector<std::string> &args, bool quiet) {
 	LOG4CXX_INFO(logger, args[1] << ": Going to join the room, checking the ID of channel " << args[5]);
-	m_api->channelsList(boost::bind(&SlackSession::handleJoinRoomList, this, _1, _2, _3, _4, args));
+	m_api->createChannel(args[5], m_rtm->getSelfId(), boost::bind(&SlackSession::handleJoinRoomCreated, this, _1, args));
+}
 void SlackSession::handleSlackChannelInvite(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data) {
 void SlackSession::handleSlackChannelCreated(const std::string &channelId) {
 	m_slackChannel = channelId;
 	Swift::Presence::ref presence = Swift::Presence::create();
 	presence->setFrom(Swift::JID("", m_uinfo.jid, "default"));
 	presence->setTo(m_component->getJID());
 	presence->setType(Swift::Presence::Available);
 	presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 	m_component->getFrontend()->onPresenceReceived(presence);
+}
 void SlackSession::handleSlackChannelCreate(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data) {
 	std::string channelId = m_api->getChannelId(req, ok, resp, data);
 	if (channelId.empty()) {
 		LOG4CXX_INFO(logger,"Error creating channel " << m_slackChannel << ".");
 		return;
+	}
 	m_slackChannel = channelId;
 	m_api->channelsInvite(m_slackChannel, m_rtm->getSelfId(), boost::bind(&SlackSession::handleSlackChannelInvite, this, _1, _2, _3, _4));
+}
 void SlackSession::handleSlackChannelList(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data) {
 	std::map<std::string, SlackChannelInfo> channels;
 	SlackAPI::getSlackChannelInfo(req, ok, resp, data, channels);
 	if (channels.find(m_slackChannel) != channels.end()) {
 		m_slackChannel = channels[m_slackChannel].id;
 		m_api->channelsInvite(m_slackChannel, m_rtm->getSelfId(), boost::bind(&SlackSession::handleSlackChannelInvite, this, _1, _2, _3, _4));
+	}
 	else {
 		m_api->channelsCreate(m_slackChannel, boost::bind(&SlackSession::handleSlackChannelCreate, this, _1, _2, _3, _4));
+	}
+}
 void SlackSession::handleLeaveMessage(const std::string &message, std::vector<std::string> &args, bool quiet) {
 	// .spectrum2 leave.room channel
 	std::string slackChannel = SlackAPI::SlackObjectToPlainText(args[2], true);
 	std::string to = m_channel2jid[slackChannel];
 	if (to.empty()) {
 		m_rtm->sendMessage(m_ownerChannel, "Spectrum 2 is not configured to transport this Slack channel.");
 		return;
+	}
 	std::string rooms = "";
 	int type = (int) TYPE_STRING;
 	m_storageBackend->getUserSetting(m_uinfo.id, "rooms", type, rooms);
 	std::vector<std::string> commands;
 	boost::split(commands, rooms, boost::is_any_of("\n"));
 	rooms = "";
 	BOOST_FOREACH(const std::string &command, commands) {
 		if (command.size() > 5) {
 			std::vector<std::string> args2;
 			boost::split(args2, command, boost::is_any_of(" "));
 			if (args2.size() == 6) {
 				if (slackChannel != SlackAPI::SlackObjectToPlainText(args2[5], true)) {
 					rooms += command + "\n";
+				}
+			}
+		}
+	}
 	m_storageBackend->updateUserSetting(m_uinfo.id, "rooms", rooms);
 	Swift::Presence::ref presence = Swift::Presence::create();
 	presence->setFrom(Swift::JID("", m_uinfo.jid, "default"));
 	presence->setTo(Swift::JID(to + "/" + m_uinfo.uin));
 	presence->setType(Swift::Presence::Unavailable);
 	presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 	m_component->getFrontend()->onPresenceReceived(presence);
+}
 void SlackSession::handleRegisterMessage(const std::string &message, std::vector<std::string> &args, bool quiet) {
 	// .spectrum2 register test@xmpp.tld mypassword #slack_channel
 	m_uinfo.uin = SlackAPI::SlackObjectToPlainText(args[2]);
 	m_uinfo.password = args[3];
 	std::string slackChannel = SlackAPI::SlackObjectToPlainText(args[4], true);
 	m_storageBackend->setUser(m_uinfo);
 	int type = (int) TYPE_STRING;
 	m_storageBackend->getUserSetting(m_uinfo.id, "slack_channel", type, slackChannel);
@@ @@ -440,92 +390,92 @@ void SlackSession::setUser(User *user) { @@
+}
 void SlackSession::handleConnected() {
 	if (m_disconnected) {
 		m_rtm->getAPI()->imOpen(m_ownerId, boost::bind(&SlackSession::handleImOpen, this, _1, _2, _3, _4));
 		m_disconnected = false;
+	}
+}
 void SlackSession::handleImOpen(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data) {
 	m_ownerChannel = m_rtm->getAPI()->getChannelId(req, ok, resp, data);
 	LOG4CXX_INFO(logger, "Opened channel with team owner: " << m_ownerChannel);
 	std::string rooms = "";
 	int type = (int) TYPE_STRING;
 	m_storageBackend->getUserSetting(m_uinfo.id, "rooms", type, rooms);
 	if (!CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "registration.needRegistration", true)) {
 		if (rooms.empty()) {
 			std::string msg;
 			msg =  "Hi, it seems you have enabled Spectrum 2 transport for your Team. As a Team owner, you should now configure it:\\n";
 			msg += "1. At first, create new channel in which you want this Spectrum 2 transport to send the messages, or choose the existing one.\\n";
 			msg += "2. Invite this Spectrum 2 bot into this channel.\\n";
 			msg += "3. Configure the transportation between 3rd-party network and this channel by executing following command in this chat:\\n";
 			msg += "```.spectrum2 join.room NameOfYourBotIn3rdPartyNetwork #3rdPartyRoom hostname_of_3rd_party_server #SlackChannel```\\n";
 			msg += "For example to join #test123 channel on Freenode IRC server as MyBot and transport it into #slack_channel, the command would look like this:\\n";
 			msg += "```.spectrum2 join.room MyBot #test123 adams.freenode.net #slack_channel```\\n";
 			msg += "To get full list of available commands, executa `.spectrum2 help`\\n";
 			m_rtm->sendMessage(m_ownerChannel, msg);
+		}
+	}
 	else {
 		if (m_uinfo.uin.empty()) {
 			std::string msg;
 			msg =  "Hi, it seems you have enabled Spectrum 2 transport for your Team. As a Team owner, you should now configure it:\\n";
 			msg += "1. At first, create new channel in which you want this Spectrum 2 transport to send the messages, or choose the existing one.\\n";
 			msg += "2. Invite this Spectrum 2 bot into this channel.\\n";
 			msg += "3. Configure the transportation between 3rd-party network and this channel by executing following command in this chat:\\n";
 			msg += "```.spectrum2 register 3rdPartyAccount 3rdPartyPassword #SlackChannel```\\n";
 			msg += "For example to join XMPP account test@xmpp.tld and  transport it into #slack_channel, the command would look like this:\\n";
 			msg += "```.spectrum2 register test@xmpp.tld mypassword #slack_channel```\\n";
 			msg += "To get full list of available commands, executa `.spectrum2 help`\\n";
 			m_rtm->sendMessage(m_ownerChannel, msg);
+		}
 		else {
 			m_storageBackend->getUserSetting(m_uinfo.id, "slack_channel", type, m_slackChannel);
 			if (!m_slackChannel.empty()) {
-				m_api->channelsList(boost::bind(&SlackSession::handleSlackChannelList, this, _1, _2, _3, _4));
+				m_api->createChannel(m_slackChannel, m_rtm->getSelfId(), boost::bind(&SlackSession::handleSlackChannelCreated, this, _1));
+			}
 			else {
 				std::string msg;
 				msg =  "Hi, it seems you have enabled Spectrum 2 transport for your Team. As a Team owner, you should now configure it:\\n";
 				msg += "1. At first, create new channel in which you want this Spectrum 2 transport to send the messages, or choose the existing one.\\n";
 				msg += "2. Invite this Spectrum 2 bot into this channel.\\n";
 				msg += "3. Configure the transportation between 3rd-party network and this channel by executing following command in this chat:\\n";
 				msg += "```.spectrum2 set_main_channel #SlackChannel```\\n";
 				msg += "To get full list of available commands, executa `.spectrum2 help`\\n";
 				m_rtm->sendMessage(m_ownerChannel, msg);
+			}
+		}
+	}
 	// Auto-join the rooms configured by the Slack channel owner.
 	if (!rooms.empty()) {
 		std::vector<std::string> commands;
 		boost::split(commands, rooms, boost::is_any_of("\n"));
 		BOOST_FOREACH(const std::string &command, commands) {
 			if (command.size() > 5) {
 				LOG4CXX_INFO(logger, m_uinfo.jid << ": Sending command from storage: " << command);
 				handleMessageReceived(m_ownerChannel, "owner", command, "", true);
+			}
+		}
+	}
+}
 void SlackSession::handleRTMStarted() {
 	std::map<std::string, SlackUserInfo> &users = m_rtm->getUsers();
 	for (std::map<std::string, SlackUserInfo>::iterator it = users.begin(); it != users.end(); it++) {
 		SlackUserInfo &info = it->second;
 		if (info.isPrimaryOwner) {
 			m_ownerId = it->first;
 			break;
+		}
+	}
 	m_rtm->getAPI()->imOpen(m_ownerId, boost::bind(&SlackSession::handleImOpen, this, _1, _2, _3, _4));
+}
+}

spectrum/src/frontends/slack/SlackSession.h

➞

Show inline comments

@@ @@ -24,77 +24,72 @@ @@
 #include "rapidjson/document.h"
 #include <string>
 #include <algorithm>
 #include <map>
 #include "Swiften/Elements/Message.h"
 #include "Swiften/Network/Timer.h"
 #include <boost/signal.hpp>
 namespace Transport {
 class Component;
 class StorageBackend;
 class HTTPRequest;
 class SlackRTM;
 class SlackAPI;
 class User;
 class SlackSession {
 	public:
 		SlackSession(Component *component, StorageBackend *storageBackend, UserInfo uinfo);
 		virtual ~SlackSession();
 		boost::signal<void (const std::string &user)> onInstallationDone;
 		void sendMessage(boost::shared_ptr<Swift::Message> message);
 		void sendMessageToAll(const std::string &msg);
 		void setPurpose(const std::string &purpose, const std::string &channel = "");
 		void setUser(User *user);
 		void handleDisconnected();
 		void handleConnected();
 		void handleJoinMessage(const std::string &message, std::vector<std::string> &args, bool quiet = false);
 		void handleLeaveMessage(const std::string &message, std::vector<std::string> &args, bool quiet = false);
 		void handleRegisterMessage(const std::string &message, std::vector<std::string> &args, bool quiet = false);
 	private:
 		void handleRTMStarted();
 		void handleMessageReceived(const std::string &channel, const std::string &user, const std::string &message, const std::string &ts, bool quiet);
 		void handleImOpen(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data);
 		void joinRoom(std::vector<std::string> args);
 		void handleJoinRoomCreate(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, std::vector<std::string> args);
 		void handleJoinRoomList(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data, std::vector<std::string> args);
 		void handleSlackChannelCreate(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data);
 		void handleSlackChannelList(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data);
 		void handleSlackChannelInvite(HTTPRequest *req, bool ok, rapidjson::Document &resp, const std::string &data);
 		void handleJoinRoomCreated(const std::string &channelId, std::vector<std::string> args);
 		void handleSlackChannelCreated(const std::string &channelId);
 		void sendOnlineBuddies();
 	private:
 		Component *m_component;
 		StorageBackend *m_storageBackend;
 		UserInfo m_uinfo;
 		std::string m_ownerName;
 		SlackRTM *m_rtm;
 		std::string m_ownerChannel;
 		std::map<std::string, std::string> m_jid2channel;
 		std::map<std::string, std::string> m_channel2jid;
 		std::string m_slackChannel;
 		User *m_user;
 		Swift::Timer::ref m_onlineBuddiesTimer;
 		std::map<std::string, std::string> m_onlineBuddies;
 		bool m_disconnected;
 		std::string m_ownerId;
 		SlackAPI *m_api;
 };
+}

0 comments (0 inline, 0 general)