m_transport->handleConnected();

}

std::string SlackFrontend::setOAuth2Code(const std::string &code, const std::string &state) {

	return static_cast<SlackUserManager *>(m_userManager)->handleOAuth2Code(code, state);

}

std::string SlackFrontend::getOAuth2URL(const std::vector<std::string> &args) {

	return static_cast<SlackUserManager *>(m_userManager)->getOAuth2URL(args);

}

std::string SlackFrontend::getRegistrationFields() {

}

bool SlackFrontend::handleAdminMessage(Swift::Message::ref message) {

	return static_cast<SlackUserManager *>(m_userManager)->handleAdminMessage(message);

}

void SlackFrontend::disconnectFromServer() {

}

}

	}

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

}

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

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

			}

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

			}

		}

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

		LOG4CXX_ERROR(logger, req.getRawData());

		return "";

	}

	return domain.GetString();

}

std::string SlackUserRegistration::handleOAuth2Code(const std::string &code, const std::string &state) {

	OAuth2 *oauth2 = NULL;

	std::string token;

	std::string access_token;

	std::vector<std::string> data;

	if (state == "use_bot_token") {

		token = code;

		access_token = code;

	}

	else {

		if (m_auths.find(state) != m_auths.end()) {

			oauth2 = m_auths[state];

			data = m_authsData[state];

		}

		else {

			return "Received state code '" + state + "' not found in state codes list.";

	std::string domain = getTeamDomain(access_token);

	if (domain.empty()) {

		return "The token you have provided is invalid";

	}

	UserInfo user;

	user.uin = "";

	user.password = "";

	user.id = 0;

	m_storageBackend->getUser(domain, user);

	user.jid = domain;

	user.language = "en";

	user.encoding = "";

	user.vip = 0;

	registerUser(user, true);

	m_storageBackend->getUser(user.jid, user);

	m_storageBackend->getUserSetting(user.id, "bot_token", type, value);

	value = access_token;

	m_storageBackend->getUserSetting(user.id, "access_token", type, value);

	LOG4CXX_INFO(logger, "Registered Slack user " << user.jid);

	if (oauth2) {

		m_auths.erase(state);

		delete oauth2;

		m_authsData.erase(state);