libtransport.git Changeset - 6cc7c334f3c4

Changeset - 6cc7c334f3c4

Parent rev.

Child rev.

[Not reviewed]

0 4 2

Sarang Bharadwaj - 13 years ago 2012-06-15 11:45:41
sarang.bh@gmail.com

Retweet

6 files changed with 109 insertions and 1 deletions:

backends/twitter/Requests/RetweetRequest.cpp

backends/twitter/Requests/RetweetRequest.h

backends/twitter/TwitterPlugin.cpp

backends/twitter/TwitterPlugin.h

backends/twitter/libtwitcurl/twitcurl.cpp

backends/twitter/libtwitcurl/twitcurl.h

0 comments (0 inline, 0 general)

backends/twitter/Requests/RetweetRequest.cpp

➞

Show inline comments

@@ new file 100644 @@
 #include "RetweetRequest.h"
 DEFINE_LOGGER(logger, "RetweetRequest")
 void RetweetRequest::run()
+{
 	LOG4CXX_INFO(logger, user << " Retweeting " << data)
 	success = twitObj->retweetById( data );
+}
 void RetweetRequest::finalize()
+{
 	replyMsg = "";
 	if(!success) {
 		twitObj->getLastCurlError( replyMsg );
 		LOG4CXX_ERROR(logger, user << " " << replyMsg)
 		callBack(user, replyMsg);
 	} else {
 		twitObj->getLastWebResponse( replyMsg );
 		std::string error = getErrorMessage( replyMsg );
 		if(error.length()) LOG4CXX_ERROR(logger, user << " " << error)
 		else LOG4CXX_INFO(logger, user << " " << replyMsg);
 		callBack(user, error);
+	}
+}

backends/twitter/Requests/RetweetRequest.h

➞

Show inline comments

@@ new file 100644 @@
 #ifndef RETWEET_H
 #define RETWEET_H
 #include "../ThreadPool.h"
 #include "../TwitterResponseParser.h"
 #include "../libtwitcurl/twitcurl.h"
 #include "transport/networkplugin.h"
 #include "transport/logging.h"
 #include <boost/function.hpp>
 #include <string>
 #include <iostream>
 using namespace Transport;
 class RetweetRequest : public Thread
+{
 	twitCurl *twitObj;
 	std::string data;
 	std::string user;
 	std::string replyMsg;
 	bool success;
 	boost::function < void (std::string&, std::string &) > callBack;
 	public:
 	RetweetRequest(twitCurl *obj, const std::string &_user, const std::string &_data,
 			       boost::function < void (std::string &, std::string &) > _cb) {
 		twitObj = obj->clone();
 		data = _data;
 		user = _user;
 		callBack = _cb;
+	}
 	~RetweetRequest() {
 		delete twitObj;
+	}
 	void run();
 	void finalize();
 };
 #endif

backends/twitter/TwitterPlugin.cpp

➞

Show inline comments

 #include "TwitterPlugin.h"
 #include "Requests/StatusUpdateRequest.h"
 #include "Requests/DirectMessageRequest.h"
 #include "Requests/TimelineRequest.h"
 #include "Requests/FetchFriends.h"
 #include "Requests/HelpMessageRequest.h"
 #include "Requests/PINExchangeProcess.h"
 #include "Requests/OAuthFlow.h"
 #include "Requests/CreateFriendRequest.h"
 #include "Requests/DestroyFriendRequest.h"
 #include "Requests/RetweetRequest.h"
 DEFINE_LOGGER(logger, "Twitter Backend");
 TwitterPlugin *np = NULL;
 Swift::SimpleEventLoop *loop_; // Event Loop
 #define abs(x) ((x)<0?-(x):(x))
 static int cmp(std::string a, std::string b)
+{
 	int diff = abs((int)a.size() - (int)b.size());
 	if(a.size() < b.size()) a = std::string(diff,'0') + a;
 	else b = std::string(diff,'0') + b;
 	if(a == b) return 0;
 	if(a < b) return -1;
 	return 1;
+}
 TwitterPlugin::TwitterPlugin(Config *config, Swift::SimpleEventLoop *loop, StorageBackend *storagebackend, const std::string &host, int port) : NetworkPlugin()
+{
 	this->config = config;
 	this->storagebackend = storagebackend;
 	if(CONFIG_HAS_KEY(config, "twitter.consumer_key") == false ||
 	   CONFIG_HAS_KEY(config, "twitter.consumer_secret") == false) {
 		LOG4CXX_ERROR(logger, "Couldn't find consumer key and/or secret. Please check config file.");
 		exit(0);
+	}
 	twitterMode = SINGLECONTACT;
 	if(CONFIG_HAS_KEY(config, "twitter.mode") == false) {
 		LOG4CXX_INFO(logger, "Using default single contact mode!");
 	} else twitterMode = (mode)CONFIG_INT(config, "twitter.mode");
 	consumerKey = CONFIG_STRING(config, "twitter.consumer_key");
 	consumerSecret = CONFIG_STRING(config, "twitter.consumer_secret");
 	OAUTH_KEY = "oauth_key";
 	OAUTH_SECRET = "oauth_secret";
 	m_factories = new Swift::BoostNetworkFactories(loop);
 	m_conn = m_factories->getConnectionFactory()->createConnection();
 	m_conn->onDataRead.connect(boost::bind(&TwitterPlugin::_handleDataRead, this, _1));
 	m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
 	tp = new ThreadPool(loop_, 10);
 	tweet_timer = m_factories->getTimerFactory()->createTimer(60000);
 	message_timer = m_factories->getTimerFactory()->createTimer(60000);
 	tweet_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForTweets, this));
 	message_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForDirectMessages, this));
 	tweet_timer->start();
 	message_timer->start();
 	LOG4CXX_INFO(logger, "Starting the plugin.");
+}
 TwitterPlugin::~TwitterPlugin()
+{
 	delete storagebackend;
 	std::map<std::string, twitCurl*>::iterator it;
 	for(it = sessions.begin() ; it != sessions.end() ; it++) delete it->second;
 	delete tp;
+}
 // Send data to NetworkPlugin server
 void TwitterPlugin::sendData(const std::string &string)
+{
 	m_conn->write(Swift::createSafeByteArray(string));
+}
 // Receive date from the NetworkPlugin server and invoke the appropirate payload handler (implement in the NetworkPlugin class)
 void TwitterPlugin::_handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data)
+{
 	std::string d(data->begin(), data->end());
 	handleDataRead(d);
+}
 // User trying to login into his twitter account
 void TwitterPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password)
+{
 	if(connectionState.count(user) && (connectionState[user] == NEW ||
 										connectionState[user] == CONNECTED ||
 										connectionState[user] == WAITING_FOR_PIN)) {
 		LOG4CXX_INFO(logger, std::string("A session corresponding to ") + user + std::string(" is already active"))
 		return;
+	}
 	LOG4CXX_INFO(logger, std::string("Received login request for ") + user)
 	initUserSession(user, password);
 	handleConnected(user);
 	handleBuddyChanged(user, "twitter-account", "twitter", std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
 	LOG4CXX_INFO(logger, "Querying database for usersettings of " << user)
 	std::string key, secret;
 	getUserOAuthKeyAndSecret(user, key, secret);
 	if(key == "" || secret == "") {
 		LOG4CXX_INFO(logger, "Intiating OAuth Flow for user " << user)
 		tp->runAsThread(new OAuthFlow(np, sessions[user], user, sessions[user]->getTwitterUsername()));
 	} else {
 		LOG4CXX_INFO(logger, user << " is already registerd. Using the stored oauth key and secret")
 		LOG4CXX_INFO(logger, key << " " << secret)
 		pinExchangeComplete(user, key, secret);
+	}
+}
 // User logging out
 void TwitterPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName)
+{
 	delete sessions[user];
 	sessions[user] = NULL;
 	connectionState[user] = DISCONNECTED;
 	onlineUsers.erase(user);
+}
 void TwitterPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml)
+{
 	if(legacyName == "twitter-account") {
 		//char ch;
 		std::string cmd = "", data = "";
 		int i;
 		for(i=0 ; i<message.size() && message[i] != ' '; i++) cmd += message[i];
 		while(i<message.size() && message[i] == ' ') i++;
 		data = message.substr(i);
 		//handleMessage(user, "twitter-account", cmd + " " + data);
 		if(cmd == "#pin") tp->runAsThread(new PINExchangeProcess(np, sessions[user], user, data));
 		else if(cmd == "#help") tp->runAsThread(new HelpMessageRequest(np, user));
 		else if(cmd[0] == '@') {
 			std::string username = cmd.substr(1);
 			tp->runAsThread(new DirectMessageRequest(sessions[user], user, username, data,
 												     boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3)));
+		}
 		else if(cmd == "#status") tp->runAsThread(new StatusUpdateRequest(np, sessions[user], user, data));
 		else if(cmd == "#timeline") tp->runAsThread(new TimelineRequest(sessions[user], user, data, "",
 														boost::bind(&TwitterPlugin::displayTweets, this, _1, _2, _3, _4)));
 		else if(cmd == "#friends") tp->runAsThread(new FetchFriends(sessions[user], user,
 													   boost::bind(&TwitterPlugin::displayFriendlist, this, _1, _2, _3)));
 		else if(cmd == "#follow") tp->runAsThread(new CreateFriendRequest(sessions[user], user, data,
 													   boost::bind(&TwitterPlugin::createFriendResponse, this, _1, _2, _3)));
 		else if(cmd == "#unfollow") tp->runAsThread(new DestroyFriendRequest(sessions[user], user, data,
 													   boost::bind(&TwitterPlugin::deleteFriendResponse, this, _1, _2, _3)));
 		else if(cmd == "#retweet") tp->runAsThread(new RetweetRequest(sessions[user], user, data,
 													   boost::bind(&TwitterPlugin::RetweetResponse, this, _1, _2)));
 		else handleMessage(user, "twitter-account", "Unknown command! Type #help for a list of available commands.");
+	}
 	else {
 		tp->runAsThread(new DirectMessageRequest(sessions[user], user, legacyName, message,
 												 boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3)));
+	}
+}
 void TwitterPlugin::handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups)
+{
 	LOG4CXX_INFO(logger, user << ": Added buddy " << buddyName << ".");
 	handleBuddyChanged(user, buddyName, alias, groups, pbnetwork::STATUS_ONLINE);
+}
 void TwitterPlugin::handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups)
+{
+}
 void TwitterPlugin::pollForTweets()
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::set<std::string>::iterator it = onlineUsers.begin();
 	while(it != onlineUsers.end()) {
 		std::string user = *it;
 		tp->runAsThread(new TimelineRequest(sessions[user], user, "", mostRecentTweetID[user],
 											boost::bind(&TwitterPlugin::displayTweets, this, _1, _2, _3, _4)));
 		it++;
+	}
 	tweet_timer->start();
+}
 void TwitterPlugin::pollForDirectMessages()
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::set<std::string>::iterator it = onlineUsers.begin();
 	while(it != onlineUsers.end()) {
 		std::string user = *it;
 		tp->runAsThread(new DirectMessageRequest(sessions[user], user, "", mostRecentDirectMessageID[user],
 											boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3)));
 		it++;
+	}
 	message_timer->start();
+}
 bool TwitterPlugin::getUserOAuthKeyAndSecret(const std::string user, std::string &key, std::string &secret)
+{
 	boost::mutex::scoped_lock lock(dblock);
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
 		return false;
+	}
 	key="", secret=""; int type;
 	storagebackend->getUserSetting((long)info.id, OAUTH_KEY, type, key);
 	storagebackend->getUserSetting((long)info.id, OAUTH_SECRET, type, secret);
 	return true;
+}
 bool TwitterPlugin::storeUserOAuthKeyAndSecret(const std::string user, const std::string OAuthKey, const std::string OAuthSecret)
+{
 	boost::mutex::scoped_lock lock(dblock);
 	UserInfo info;
 	if(storagebackend->getUser(user, info) == false) {
 		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
 		return false;
+	}
 	storagebackend->updateUserSetting((long)info.id, OAUTH_KEY, OAuthKey);
 	storagebackend->updateUserSetting((long)info.id, OAUTH_SECRET, OAuthSecret);
 	return true;
+}
 void TwitterPlugin::initUserSession(const std::string user, const std::string password)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::string username = user.substr(0,user.find('@'));
 	std::string passwd = password;
 	LOG4CXX_INFO(logger, username + "  " + passwd)
 	sessions[user] = new twitCurl();
 	if(CONFIG_HAS_KEY(config,"proxy.server")) {
 		std::string ip = CONFIG_STRING(config,"proxy.server");
 		std::ostringstream out;
 		out << CONFIG_INT(config,"proxy.port");
 		std::string port = out.str();
+	}
 	connectionState[user] = NEW;
 	sessions[user]->setTwitterUsername(username);
 	sessions[user]->setTwitterPassword(passwd);
 	sessions[user]->getOAuth().setConsumerKey(consumerKey);
 	sessions[user]->getOAuth().setConsumerSecret(consumerSecret);
+}
 void TwitterPlugin::OAuthFlowComplete(const std::string user, twitCurl *obj)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	delete sessions[user];
 	sessions[user] = obj->clone();
 	connectionState[user] = WAITING_FOR_PIN;
+}
 void TwitterPlugin::pinExchangeComplete(const std::string user, const std::string OAuthAccessTokenKey, const std::string OAuthAccessTokenSecret)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	sessions[user]->getOAuth().setOAuthTokenKey( OAuthAccessTokenKey );
 	sessions[user]->getOAuth().setOAuthTokenSecret( OAuthAccessTokenSecret );
 	connectionState[user] = CONNECTED;
 	if(twitterMode == MULTIPLECONTACT) {
 		tp->runAsThread(new FetchFriends(sessions[user], user,
 										 boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3)));
+	}
 	onlineUsers.insert(user);
 	mostRecentTweetID[user] = "";
 	mostRecentDirectMessageID[user] = "";
+}
 void TwitterPlugin::updateLastTweetID(const std::string user, const std::string ID)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	mostRecentTweetID[user] = ID;
+}
 std::string TwitterPlugin::getMostRecentTweetID(const std::string user)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::string ID = "-1";
 	if(onlineUsers.count(user)) ID = mostRecentTweetID[user];
 	return ID;
+}
 void TwitterPlugin::updateLastDMID(const std::string user, const std::string ID)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	mostRecentDirectMessageID[user] = ID;
+}
 std::string TwitterPlugin::getMostRecentDMID(const std::string user)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	std::string ID = "";
 	if(onlineUsers.count(user)) ID = mostRecentDirectMessageID[user];
 	return ID;
+}
 /************************************** Twitter response functions **********************************/
 void TwitterPlugin::populateRoster(std::string &user, std::vector<User> &friends, std::string &errMsg)
+{
 	if(errMsg.length() == 0)
+	{
 		for(int i=0 ; i<friends.size() ; i++) {
 			handleBuddyChanged(user, friends[i].getScreenName(), friends[i].getUserName(), std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
+		}
 	} else handleMessage(user, "twitter-account", std::string("Error populating roster - ") + errMsg);
+}
 void TwitterPlugin::displayFriendlist(std::string &user, std::vector<User> &friends, std::string &errMsg)
+{
 	if(errMsg.length() == 0)
+	{
 		std::string userlist = "\n***************USER LIST****************\n";
 		for(int i=0 ; i < friends.size() ; i++) {
 			userlist += " - " + friends[i].getUserName() + " (" + friends[i].getScreenName() + ")\n";
+		}
 		userlist += "***************************************\n";
 		handleMessage(user, "twitter-account", userlist);
 	} else handleMessage(user, "twitter-account", errMsg);
+}
 void TwitterPlugin::displayTweets(std::string &user, std::string &userRequested, std::vector<Status> &tweets , std::string &errMsg)
+{
 	if(errMsg.length() == 0) {
 		std::string timeline = "";
 		for(int i=0 ; i<tweets.size() ; i++) {
 			timeline += " - " + tweets[i].getUserData().getScreenName() + ": " + tweets[i].getTweet() + "\n";
+			timeline += " - " + tweets[i].getUserData().getScreenName() + ": " + tweets[i].getTweet() + " (MsgId: " + tweets[i].getID() + ")\n";
+		}
 		if((userRequested == "" || userRequested == user) && tweets.size()) {
 			std::string tweetID = getMostRecentTweetID(user);
 			if(tweetID != tweets[0].getID()) updateLastTweetID(user, tweets[0].getID());
 			else timeline = ""; //have already sent the tweet earlier
+		}
 		if(timeline.length()) handleMessage(user, "twitter-account", timeline);
 	} else handleMessage(user, "twitter-account", errMsg);
+}
 void TwitterPlugin::directMessageResponse(std::string &user, std::vector<DirectMessage> &messages, std::string &errMsg)
+{
 	if(errMsg.length()) {
 		handleMessage(user, "twitter-account", std::string("Error while sending direct message! - ") + errMsg);
 		return;
+	}
 	if(!messages.size()) return;
 	if(twitterMode == SINGLECONTACT) {
 		std::string msglist = "";
 		std::string msgID = getMostRecentDMID(user);
 		std::string maxID = msgID;
 		for(int i=0 ; i < messages.size() ; i++) {
 			if(cmp(msgID, messages[i].getID()) == -1) {
 				msglist += " - " + messages[i].getSenderData().getScreenName() + ": " + messages[i].getMessage() + "\n";
 				if(cmp(maxID, messages[i].getID()) == -1) maxID = messages[i].getID();
+			}
+		}
 		if(msglist.length()) handleMessage(user, "twitter-account", msglist);
 		updateLastDMID(user, maxID);
 	} else if(twitterMode == MULTIPLECONTACT) {
 		std::string msgID = getMostRecentDMID(user);
 		std::string maxID = msgID;
 		for(int i=0 ; i < messages.size() ; i++) {
 			if(cmp(msgID, messages[i].getID()) == -1) {
 				handleMessage(user, messages[i].getSenderData().getScreenName(), messages[i].getMessage());
 				if(cmp(maxID, messages[i].getID()) == -1) maxID = messages[i].getID();
+			}
+		}
 		if(maxID == getMostRecentDMID(user)) LOG4CXX_INFO(logger, "No new direct messages for " << user)
 		updateLastDMID(user, maxID);
+	}
+}
 void TwitterPlugin::createFriendResponse(std::string &user, std::string &frnd, std::string &errMsg)
+{
 	if(errMsg.length()) {
 		handleMessage(user, "twitter-account", errMsg);
 		return;
+	}
 	if(twitterMode == SINGLECONTACT) {
 		handleMessage(user, "twitter-account", std::string("You are now following ") + frnd);
 	} else if(twitterMode == MULTIPLECONTACT) {
 		handleBuddyChanged(user, frnd, frnd, std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
+	}
+}
 void TwitterPlugin::deleteFriendResponse(std::string &user, std::string &frnd, std::string &errMsg)
+{
 	if(errMsg.length()) {
 		handleMessage(user, "twitter-account", errMsg);
 		return;
 	} if(twitterMode == SINGLECONTACT) {
 		handleMessage(user, "twitter-account", std::string("You are not following ") + frnd + "anymore");
 	} else if(twitterMode == MULTIPLECONTACT) {
+	}
+}
 void TwitterPlugin::RetweetResponse(std::string &user, std::string &errMsg)
+{
 	if(errMsg.length()) {
 		handleMessage(user, "twitter-account", errMsg);
 		return;
+	}
+}

backends/twitter/TwitterPlugin.h

➞

Show inline comments

@@ @@ -9,121 +9,122 @@ @@
 #include "transport/pqxxbackend.h"
 #include "transport/storagebackend.h"
 #include "Swiften/Swiften.h"
 #include "unistd.h"
 #include "signal.h"
 #include "sys/wait.h"
 #include "sys/signal.h"
 #include <boost/algorithm/string.hpp>
 #include <boost/signal.hpp>
 #include <boost/thread.hpp>
 #include <boost/thread/mutex.hpp>
 #include "twitcurl.h"
 #include "TwitterResponseParser.h"
 #include <iostream>
 #include <sstream>
 #include <map>
 #include <vector>
 #include <queue>
 #include <set>
 #include <cstdio>
 #include "ThreadPool.h"
 using namespace boost::filesystem;
 using namespace boost::program_options;
 using namespace Transport;
 #define STR(x) (std::string("(") + x.from + ", " + x.to + ", " + x.message + ")")
 class TwitterPlugin;
 extern TwitterPlugin *np;
 extern Swift::SimpleEventLoop *loop_; // Event Loop
 class TwitterPlugin : public NetworkPlugin {
 	public:
 		Swift::BoostNetworkFactories *m_factories;
 		Swift::BoostIOServiceThread m_boostIOServiceThread;
 		boost::shared_ptr<Swift::Connection> m_conn;
 		Swift::Timer::ref tweet_timer;
 		Swift::Timer::ref message_timer;
 		StorageBackend *storagebackend;
 		TwitterPlugin(Config *config, Swift::SimpleEventLoop *loop, StorageBackend *storagebackend, const std::string &host, int port);
 		~TwitterPlugin();
 		// Send data to NetworkPlugin server
 		void sendData(const std::string &string);
 		// Receive date from the NetworkPlugin server and invoke the appropirate payload handler (implement in the NetworkPlugin class)
 		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data);
 		// User trying to login into his twitter account
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password);
 		// User logging out
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName);
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "");
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups);
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups);
 		void pollForTweets();
 		void pollForDirectMessages();
 		bool getUserOAuthKeyAndSecret(const std::string user, std::string &key, std::string &secret);
 		bool storeUserOAuthKeyAndSecret(const std::string user, const std::string OAuthKey, const std::string OAuthSecret);
 		void initUserSession(const std::string user, const std::string password);
 		void OAuthFlowComplete(const std::string user, twitCurl *obj);
 		void pinExchangeComplete(const std::string user, const std::string OAuthAccessTokenKey, const std::string OAuthAccessTokenSecret);
 		void updateLastTweetID(const std::string user, const std::string ID);
 		std::string getMostRecentTweetID(const std::string user);
 		void updateLastDMID(const std::string user, const std::string ID);
 		std::string getMostRecentDMID(const std::string user);
 		/****************** Twitter Response handlers **************************************/
 		void populateRoster(std::string &user, std::vector<User> &friends, std::string &errMsg);
 		void displayFriendlist(std::string &user, std::vector<User> &friends, std::string &errMsg);
 		void displayTweets(std::string &user, std::string &userRequested, std::vector<Status> &tweets , std::string &errMsg);
 		void directMessageResponse(std::string &user, std::vector<DirectMessage> &messages, std::string &errMsg);
 		void createFriendResponse(std::string &user, std::string &frnd, std::string &errMsg);
 		void deleteFriendResponse(std::string &user, std::string &frnd, std::string &errMsg);
 		void RetweetResponse(std::string &user, std::string &errMsg);
 		/***********************************************************************************/
 	private:
 		enum status {NEW, WAITING_FOR_PIN, CONNECTED, DISCONNECTED};
 		enum mode {SINGLECONTACT, MULTIPLECONTACT, CHATROOM};
 		Config *config;
 		std::string consumerKey;
 		std::string consumerSecret;
 		std::string OAUTH_KEY;
 		std::string OAUTH_SECRET;
 		boost::mutex dblock, userlock;
 		ThreadPool *tp;
 		std::map<std::string, twitCurl*> sessions;
 		std::map<std::string, status> connectionState;
 		std::map<std::string, std::string> mostRecentTweetID;
 		std::map<std::string, std::string> mostRecentDirectMessageID;
 		std::set<std::string> onlineUsers;
 		mode twitterMode;
 };
 #endif

backends/twitter/libtwitcurl/twitcurl.cpp

➞

Show inline comments

 *          response by twitter. Use getLastWebResponse() for that.
+*
 * @note: Only ATOM and JSON format supported.
+*
 *--*/
 bool twitCurl::search( std::string& searchQuery )
+{
     /* Prepare URL */
     std::string buildUrl = twitterDefaults::TWITCURL_SEARCH_URL +
                            twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[twitCurlTypes::eTwitCurlApiFormatJson] +
                            twitCurlDefaults::TWITCURL_URL_SEP_QUES + twitCurlDefaults::TWITCURL_SEARCHQUERYSTRING +
                            searchQuery;
     /* Perform GET */
     return performGet( buildUrl );
+}
 /*++
 * @method: twitCurl::statusUpdate
+*
 * @description: method to update new status message in twitter profile
+*
 * @input: newStatus
+*
 * @output: true if POST is success, otherwise false. This does not check http
 *          response by twitter. Use getLastWebResponse() for that.
+*
 *--*/
 bool twitCurl::statusUpdate( std::string& newStatus )
+{
     bool retVal = false;
     if( newStatus.length() )
+    {
         /* Prepare new status message */
         std::string newStatusMsg = twitCurlDefaults::TWITCURL_STATUSSTRING + urlencode( newStatus );
         /* Perform POST */
         retVal = performPost( twitterDefaults::TWITCURL_STATUSUPDATE_URL +
                               twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
                               newStatusMsg );
+    }
     return retVal;
+}
 /*++
 * @method: twitCurl::statusShowById
+*
 * @description: method to get a status message by its id
+*
 * @input: statusId - a number in std::string format
+*
 * @output: true if GET is success, otherwise false. This does not check http
 *          response by twitter. Use getLastWebResponse() for that.
+*
 *--*/
 bool twitCurl::statusShowById( std::string& statusId )
+{
     bool retVal = false;
     if( statusId.length() )
+    {
         /* Prepare URL */
         std::string buildUrl = twitterDefaults::TWITCURL_STATUSSHOW_URL + statusId +
                                twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
         /* Perform GET */
         retVal = performGet( buildUrl );
+    }
     return retVal;
+}
 /*++
 * @method: twitCurl::statusDestroyById
+*
 * @description: method to delete a status message by its id
+*
 * @input: statusId - a number in std::string format
+*
 * @output: true if DELETE is success, otherwise false. This does not check http
 *          response by twitter. Use getLastWebResponse() for that.
+*
 *--*/
 bool twitCurl::statusDestroyById( std::string& statusId )
+{
     bool retVal = false;
     if( statusId.length() )
+    {
         /* Prepare URL */
         std::string buildUrl = twitterDefaults::TWITCURL_STATUDESTROY_URL + statusId +
                                twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
         /* Perform DELETE */
         retVal = performDelete( buildUrl );
+    }
     return retVal;
+}
 /*++
 * @method: twitCurl::retweetById
+*
 * @description: method to retweet a status message by its id
+*
 * @input: statusId - a number in std::string format
+*
 * @output: true if RETWEET is success, otherwise false. This does not check http
 *          response by twitter. Use getLastWebResponse() for that.
+*
 *--*/
 bool twitCurl::retweetById( std::string& statusId )
+{
     bool retVal = false;
     if( statusId.length() )
+    {
         /* Prepare URL */
         std::string buildUrl = twitterDefaults::TWITCURL_RETWEET_URL + statusId +
                                twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
         /* Send some dummy data in POST */
         std::string dummyData = twitCurlDefaults::TWITCURL_TEXTSTRING +
                                 urlencode( std::string( "dummy" ) );
         /* Perform Retweet */
         retVal = performPost( buildUrl, dummyData );
+    }
     return retVal;
+}
 /*++
 * @method: twitCurl::timelinePublicGet
+*
 * @description: method to get public timeline
+*
 * @input: none
+*
 * @output: true if GET is success, otherwise false. This does not check http
 *          response by twitter. Use getLastWebResponse() for that.
+*
 *--*/
 bool twitCurl::timelinePublicGet()
+{
     /* Perform GET */
     return performGet( twitterDefaults::TWITCURL_PUBLIC_TIMELINE_URL +
                        twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
+}
 /*++
 * @method: twitCurl::timelineHomeGet
+*
 * @description: method to get home timeline
+*
 * @input: none
+*
 * @output: true if GET is success, otherwise false. This does not check http
 *          response by twitter. Use getLastWebResponse() for that.
+*
 *--*/
 bool twitCurl::timelineHomeGet(std::string sinceId)
+{
     std::string buildUrl = twitterDefaults::TWITCURL_HOME_TIMELINE_URL +
                            twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
     if( sinceId.length() )
+    {
         buildUrl += twitCurlDefaults::TWITCURL_URL_SEP_QUES + twitCurlDefaults::TWITCURL_SINCEID + sinceId;
+    }
     /* Perform GET */
     return performGet( buildUrl );
+}
 /*++
 * @method: twitCurl::featuredUsersGet
+*
 * @description: method to get featured users
+*
 * @input: none
+*
 * @output: true if GET is success, otherwise false. This does not check http
 *          response by twitter. Use getLastWebResponse() for that.
+*
 *--*/
 bool twitCurl::featuredUsersGet()
+{
     /* Perform GET */
     return performGet( twitterDefaults::TWITCURL_FEATURED_USERS_URL +
                        twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
+}
 /*++
 * @method: twitCurl::timelineFriendsGet
+*
 * @description: method to get friends timeline
+*
 * @input: none
+*
 * @output: true if GET is success, otherwise false. This does not check http
 *          response by twitter. Use getLastWebResponse() for that.
+*
 *--*/
 bool twitCurl::timelineFriendsGet()
+{
     /* Perform GET */
     return performGet( twitterDefaults::TWITCURL_FRIENDS_TIMELINE_URL +
                        twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
+}
 /*++
 * @method: twitCurl::mentionsGet
+*
 * @description: method to get mentions
+*
 * @input: sinceId - String specifying since id parameter
+*
 * @output: true if GET is success, otherwise false. This does not check http
 *          response by twitter. Use getLastWebResponse() for that.
+*
 *--*/
 bool twitCurl::mentionsGet( std::string sinceId )
+{
     std::string buildUrl = twitterDefaults::TWITCURL_MENTIONS_URL +
                            twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
     if( sinceId.length() )
+    {
         buildUrl += twitCurlDefaults::TWITCURL_URL_SEP_QUES + twitCurlDefaults::TWITCURL_SINCEID + sinceId;
+    }

backends/twitter/libtwitcurl/twitcurl.h

➞

Show inline comments

 #ifndef _TWITCURL_H_
 #define _TWITCURL_H_
 #include <string>
 #include <vector>
 #include <iostream>
 #include <sstream>
 #include <cstring>
 #include "oauthlib.h"
 #include "curl/curl.h"
 namespace twitCurlTypes
+{
     typedef enum _eTwitCurlApiFormatType
+    {
         eTwitCurlApiFormatXml = 0,
         eTwitCurlApiFormatJson,
         eTwitCurlApiFormatMax
     } eTwitCurlApiFormatType;
 };
 /* Default values used in twitcurl */
 namespace twitCurlDefaults
+{
     /* Constants */
     const int TWITCURL_DEFAULT_BUFFSIZE = 1024;
     const std::string TWITCURL_COLON = ":";
     const char TWITCURL_EOS = '\0';
     const unsigned int MAX_TIMELINE_TWEET_COUNT = 200;
     /* Miscellaneous data used to build twitter URLs*/
     const std::string TWITCURL_STATUSSTRING = "status=";
     const std::string TWITCURL_TEXTSTRING = "text=";
     const std::string TWITCURL_QUERYSTRING = "query=";
     const std::string TWITCURL_SEARCHQUERYSTRING = "q=";
     const std::string TWITCURL_SCREENNAME = "screen_name=";
     const std::string TWITCURL_USERID = "user_id=";
     const std::string TWITCURL_EXTENSIONFORMATS[2] = { ".xml",
                                                        ".json"
                                                      };
     const std::string TWITCURL_TARGETSCREENNAME = "target_screen_name=";
     const std::string TWITCURL_TARGETUSERID = "target_id=";
     const std::string TWITCURL_SINCEID = "since_id=";
     const std::string TWITCURL_TRIMUSER = "trim_user=1";
     const std::string TWITCURL_INCRETWEETS = "include_rts=1";
     const std::string TWITCURL_COUNT = "count=";
     /* URL separators */
     const std::string TWITCURL_URL_SEP_AMP = "&";
     const std::string TWITCURL_URL_SEP_QUES = "?";
 };
 /* Default twitter URLs */
 namespace twitterDefaults
+{
     /* Search URLs */
     const std::string TWITCURL_SEARCH_URL = "http://search.twitter.com/search";
     /* Status URLs */
     const std::string TWITCURL_STATUSUPDATE_URL = "http://api.twitter.com/1/statuses/update";
     const std::string TWITCURL_STATUSSHOW_URL = "http://api.twitter.com/1/statuses/show/";
     const std::string TWITCURL_STATUDESTROY_URL = "http://api.twitter.com/1/statuses/destroy/";
 	const std::string TWITCURL_RETWEET_URL = "http://api.twitter.com/1/statuses/retweet/";
     /* Timeline URLs */
     const std::string TWITCURL_HOME_TIMELINE_URL = "http://api.twitter.com/1/statuses/home_timeline";
     const std::string TWITCURL_PUBLIC_TIMELINE_URL = "http://api.twitter.com/1/statuses/public_timeline";
     const std::string TWITCURL_FEATURED_USERS_URL = "http://api.twitter.com/1/statuses/featured";
     const std::string TWITCURL_FRIENDS_TIMELINE_URL = "http://api.twitter.com/1/statuses/friends_timeline";
     const std::string TWITCURL_MENTIONS_URL = "http://api.twitter.com/1/statuses/mentions";
     const std::string TWITCURL_USERTIMELINE_URL = "http://api.twitter.com/1/statuses/user_timeline";
     /* Users URLs */
 	const std::string TWITCURL_LOOKUPUSERS_URL = "http://api.twitter.com/1/users/lookup";
     const std::string TWITCURL_SHOWUSERS_URL = "http://api.twitter.com/1/users/show";
     const std::string TWITCURL_SHOWFRIENDS_URL = "http://api.twitter.com/1/statuses/friends";
     const std::string TWITCURL_SHOWFOLLOWERS_URL = "http://api.twitter.com/1/statuses/followers";
     /* Direct messages URLs */
     const std::string TWITCURL_DIRECTMESSAGES_URL = "http://api.twitter.com/1/direct_messages";
     const std::string TWITCURL_DIRECTMESSAGENEW_URL = "http://api.twitter.com/1/direct_messages/new";
     const std::string TWITCURL_DIRECTMESSAGESSENT_URL = "http://api.twitter.com/1/direct_messages/sent";
     const std::string TWITCURL_DIRECTMESSAGEDESTROY_URL = "http://api.twitter.com/1/direct_messages/destroy/";
     /* Friendships URLs */
     const std::string TWITCURL_FRIENDSHIPSCREATE_URL = "http://api.twitter.com/1/friendships/create";
     const std::string TWITCURL_FRIENDSHIPSDESTROY_URL = "http://api.twitter.com/1/friendships/destroy";
     const std::string TWITCURL_FRIENDSHIPSSHOW_URL = "http://api.twitter.com/1/friendships/show";
     /* Social graphs URLs */
     const std::string TWITCURL_FRIENDSIDS_URL = "http://api.twitter.com/1/friends/ids";
     const std::string TWITCURL_FOLLOWERSIDS_URL = "http://api.twitter.com/1/followers/ids";
     /* Account URLs */
     const std::string TWITCURL_ACCOUNTRATELIMIT_URL = "http://api.twitter.com/1/account/rate_limit_status";
     /* Favorites URLs */
     const std::string TWITCURL_FAVORITESGET_URL = "http://api.twitter.com/1/favorites";
     const std::string TWITCURL_FAVORITECREATE_URL = "http://api.twitter.com/1/favorites/create/";
     const std::string TWITCURL_FAVORITEDESTROY_URL = "http://api.twitter.com/1/favorites/destroy/";
     /* Block URLs */
     const std::string TWITCURL_BLOCKSCREATE_URL = "http://api.twitter.com/1/blocks/create/";
     const std::string TWITCURL_BLOCKSDESTROY_URL = "http://api.twitter.com/1/blocks/destroy/";
     /* Saved Search URLs */
     const std::string TWITCURL_SAVEDSEARCHGET_URL = "http://api.twitter.com/1/saved_searches";
     const std::string TWITCURL_SAVEDSEARCHSHOW_URL = "http://api.twitter.com/1/saved_searches/show/";
     const std::string TWITCURL_SAVEDSEARCHCREATE_URL = "http://api.twitter.com/1/saved_searches/create";
     const std::string TWITCURL_SAVEDSEARCHDESTROY_URL = "http://api.twitter.com/1/saved_searches/destroy/";
     /* Trends URLs */
     const std::string TWITCURL_TRENDS_URL = "http://api.twitter.com/1/trends";
     const std::string TWITCURL_TRENDSDAILY_URL = "http://api.twitter.com/1/trends/daily";
     const std::string TWITCURL_TRENDSCURRENT_URL = "http://api.twitter.com/1/trends/current";
     const std::string TWITCURL_TRENDSWEEKLY_URL = "http://api.twitter.com/1/trends/weekly";
     const std::string TWITCURL_TRENDSAVAILABLE_URL = "http://api.twitter.com/1/trends/available";
 };
 /* twitCurl class */
 class twitCurl
+{
 public:
     twitCurl();
     ~twitCurl();
     /* Twitter OAuth authorization methods */
     oAuth& getOAuth();
     bool oAuthRequestToken( std::string& authorizeUrl /* out */ );
     bool oAuthAccessToken();
     bool oAuthHandlePIN( const std::string& authorizeUrl /* in */ );
     /* Twitter login APIs, set once and forget */
     std::string& getTwitterUsername();
     std::string& getTwitterPassword();
     void setTwitterUsername( std::string& userName /* in */ );
     void setTwitterPassword( std::string& passWord /* in */ );
     /* Twitter API type */
     void setTwitterApiType( twitCurlTypes::eTwitCurlApiFormatType eType );
     /* Twitter search APIs */
     bool search( std::string& searchQuery /* in */ );
     /* Twitter status APIs */
     bool statusUpdate( std::string& newStatus /* in */ );
     bool statusShowById( std::string& statusId /* in */ );
     bool statusDestroyById( std::string& statusId /* in */ );
 	bool retweetById( std::string& statusId /* in */);
     /* Twitter timeline APIs */
     bool timelineHomeGet(std::string sinceId = ""  /* in */);
     bool timelinePublicGet();
     bool timelineFriendsGet();
     bool timelineUserGet( bool trimUser /* in */, bool includeRetweets /* in */, unsigned int tweetCount /* in */, std::string userInfo = "" /* in */, bool isUserId = false /* in */ );
     bool featuredUsersGet();
     bool mentionsGet( std::string sinceId = "" /* in */ );
     /* Twitter user APIs */
 	bool userLookup( std::vector<std::string> &userInfo /* in */,  bool isUserId = false /* in */);
     bool userGet( std::string& userInfo /* in */, bool isUserId = false /* in */ );
     bool friendsGet( std::string userInfo = "" /* in */, bool isUserId = false /* in */ );
     bool followersGet( std::string userInfo = "" /* in */, bool isUserId = false /* in */ );
     /* Twitter direct message APIs */
     bool directMessageGet( std::string sinceId /* in */ );
     bool directMessageSend( std::string& userInfo /* in */, std::string& dMsg /* in */, bool isUserId = false /* in */ );
     bool directMessageGetSent();
     bool directMessageDestroyById( std::string& dMsgId /* in */ );
     /* Twitter friendships APIs */
     bool friendshipCreate( std::string& userInfo /* in */, bool isUserId = false /* in */ );
     bool friendshipDestroy( std::string& userInfo /* in */, bool isUserId = false /* in */ );
     bool friendshipShow( std::string& userInfo /* in */, bool isUserId = false /* in */ );
     /* Twitter social graphs APIs */
     bool friendsIdsGet( std::string& userInfo /* in */, bool isUserId = false /* in */ );
     bool followersIdsGet( std::string& userInfo /* in */, bool isUserId = false /* in */ );
     /* Twitter account APIs */
     bool accountRateLimitGet();
     /* Twitter favorites APIs */
     bool favoriteGet();
     bool favoriteCreate( std::string& statusId /* in */ );
     bool favoriteDestroy( std::string& statusId /* in */ );
     /* Twitter block APIs */
     bool blockCreate( std::string& userInfo /* in */ );
     bool blockDestroy( std::string& userInfo /* in */ );
     /* Twitter search APIs */
     bool savedSearchGet();
     bool savedSearchCreate( std::string& query /* in */ );
     bool savedSearchShow( std::string& searchId /* in */ );
     bool savedSearchDestroy( std::string& searchId /* in */ );
     /* Twitter trends APIs (JSON) */
     bool trendsGet();
     bool trendsDailyGet();
     bool trendsWeeklyGet();
     bool trendsCurrentGet();
     bool trendsAvailableGet();
     /* cURL APIs */
     bool isCurlInit();
     void getLastWebResponse( std::string& outWebResp /* out */ );
     void getLastCurlError( std::string& outErrResp /* out */);
     /* Internal cURL related methods */
     int saveLastWebResponse( char*& data, size_t size );
     /* cURL proxy APIs */
     std::string& getProxyServerIp();
     std::string& getProxyServerPort();
     std::string& getProxyUserName();
     std::string& getProxyPassword();
     void setProxyServerIp( std::string& proxyServerIp /* in */ );
     void setProxyServerPort( std::string& proxyServerPort /* in */ );
     void setProxyUserName( std::string& proxyUserName /* in */ );
     void setProxyPassword( std::string& proxyPassword /* in */ );
 	twitCurl* clone();
 private:
     /* cURL data */
     CURL* m_curlHandle;
     char m_errorBuffer[twitCurlDefaults::TWITCURL_DEFAULT_BUFFSIZE];
     std::string m_callbackData;
     /* cURL flags */
     bool m_curlProxyParamsSet;
     bool m_curlLoginParamsSet;
     bool m_curlCallbackParamsSet;
     /* cURL proxy data */
     std::string m_proxyServerIp;
     std::string m_proxyServerPort;
     std::string m_proxyUserName;
     std::string m_proxyPassword;
     /* Twitter data */
     std::string m_twitterUsername;
     std::string m_twitterPassword;

0 comments (0 inline, 0 general)