libtransport.git Changeset - 561a55e96363

Changeset - 561a55e96363

Parent rev.

Child rev.

[Not reviewed]

0 2 0

Sarang Bharadwaj - 13 years ago 2012-08-07 07:26:50
sarang.bh@gmail.com

Made code compatible with spectrum 1 user DB

2 files changed with 40 insertions and 14 deletions:

backends/twitter/TwitterPlugin.cpp

backends/twitter/TwitterPlugin.h

0 comments (0 inline, 0 general)

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"
 #include "Requests/ProfileImageRequest.h"
 #include "Swiften/StringCodecs/Hexify.h"
 DEFINE_LOGGER(logger, "Twitter Backend");
 TwitterPlugin *np = NULL;
 Swift::SimpleEventLoop *loop_; // Event Loop
 const std::string OLD_APP_KEY = "PCWAdQpyyR12ezp2fVwEhw";
 const std::string OLD_APP_SECRET = "EveLmCXJIg2R7BTCpm6OWV8YyX49nI0pxnYXh7JMvDg";
 #define abs(x) ((x)<0?-(x):(x))
 //#define SHA(x) (convertToChars(Swift::byteArrayToString(Swift::SHA1::getHash(Swift::createByteArray((x))))))
 #define SHA(x) (Swift::Hexify::hexify(Swift::SHA1::getHash(Swift::createByteArray((x)))))
 //static std::string convertToChars(std::string s)
 //{
 //	std::string ret = "";
 //	std::string tab[] = {"0","1","2","3","4","5","6","7",
 //						 "8","9","A","B","C","D","E","F"};
 //	for(int i = 0 ; i < s.size() ; i++)
 //		ret = tab[s[i]>>4&15] + tab[s[i]&15] + ret;
 //	return ret;
 //}
 //Compares two +ve intergers 'a' and 'b' represented as strings
 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);
+	}
@@ @@ -100,48 +92,50 @@ 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(userdb.count(user) && (userdb[user].connectionState == NEW ||
 										userdb[user].connectionState == CONNECTED ||
 										userdb[user].connectionState == 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, legacyName, password);
 	handleConnected(user);
 	LOG4CXX_INFO(logger, "SPECTRUM 1 USER? - " << (userdb[user].spectrum1User? "true" : "false"))
 	LOG4CXX_INFO(logger, user << ": Adding Buddy " << adminLegacyName << " " << adminAlias)
 	handleBuddyChanged(user, adminLegacyName, adminAlias, std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
 	userdb[user].nickName = "";
 	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)
 		setTwitterMode(user, 0);
 		tp->runAsThread(new OAuthFlow(np, userdb[user].sessions, user, userdb[user].sessions->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)
+{
 	if(onlineUsers.count(user)) {
 		delete userdb[user].sessions;
@@ @@ -335,48 +329,68 @@ void TwitterPlugin::pollForDirectMessages() @@
 		tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, "", userdb[user].mostRecentDirectMessageID,
 											boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
 		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::checkSpectrum1User(const std::string user)
+{
 	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;
+	}
 	std::string first_synchronization_done = "";
 	int type;
 	storagebackend->getUserSetting((long)info.id, "first_synchronization_done", type, first_synchronization_done);
 	LOG4CXX_INFO(logger, "first_synchronization_done: " << first_synchronization_done)
 	if(first_synchronization_done.length()) return true;
 	return false;
+}
 int TwitterPlugin::getTwitterMode(const std::string user)
+{
 	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 -1;
+	}
 	int type; int m;
 	std::string s_m;
 	storagebackend->getUserSetting((long)info.id, MODE, type, s_m);
 	if(s_m == "") {
 		s_m  = "0";
 		storagebackend->updateUserSetting((long)info.id, MODE, s_m);
+	}
 	m = atoi(s_m.c_str());
 	return m;
+}
 bool TwitterPlugin::setTwitterMode(const std::string user, int m)
+{
 	boost::mutex::scoped_lock lock(dblock);
 	std::string passwd = password;
 	LOG4CXX_INFO(logger, username + "  " + passwd)
 	userdb[user].sessions = 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();
 		std::string puser = CONFIG_STRING(config,"proxy.user");
 		std::string ppasswd = CONFIG_STRING(config,"proxy.password");
 		LOG4CXX_INFO(logger, ip << " " << port << " " << puser << " " << ppasswd)
 		if(ip != "localhost" && port != "0") {
 			userdb[user].sessions->setProxyServerIp(ip);
 			userdb[user].sessions->setProxyServerPort(port);
 			userdb[user].sessions->setProxyUserName(puser);
 			userdb[user].sessions->setProxyPassword(ppasswd);
+		}
+	}
 	//Check if the user is spectrum1 user
 	userdb[user].spectrum1User = checkSpectrum1User(user);
 	userdb[user].connectionState = NEW;
 	userdb[user].legacyName = username;
 	userdb[user].sessions->setTwitterUsername(username);
 	userdb[user].sessions->setTwitterPassword(passwd);
 	userdb[user].sessions->getOAuth().setConsumerKey(consumerKey);
 	userdb[user].sessions->getOAuth().setConsumerSecret(consumerSecret);
 	userdb[user].sessions->setTwitterPassword(passwd);
 	if(!userdb[user].spectrum1User) {
 		userdb[user].sessions->getOAuth().setConsumerKey(consumerKey);
 		userdb[user].sessions->getOAuth().setConsumerSecret(consumerSecret);
 	} else {
 		userdb[user].sessions->getOAuth().setConsumerKey(OLD_APP_KEY);
 		userdb[user].sessions->getOAuth().setConsumerSecret(OLD_APP_SECRET);
+	}
+}
 void TwitterPlugin::OAuthFlowComplete(const std::string user, twitCurl *obj)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	delete userdb[user].sessions;
 	userdb[user].sessions = obj->clone();
 	userdb[user].connectionState = WAITING_FOR_PIN;
+}
 void TwitterPlugin::pinExchangeComplete(const std::string user, const std::string OAuthAccessTokenKey, const std::string OAuthAccessTokenSecret)
+{
 	boost::mutex::scoped_lock lock(userlock);
 	userdb[user].sessions->getOAuth().setOAuthTokenKey( OAuthAccessTokenKey );
 	userdb[user].sessions->getOAuth().setOAuthTokenSecret( OAuthAccessTokenSecret );
 	userdb[user].connectionState = CONNECTED;
 	userdb[user].twitterMode = (mode)getTwitterMode(user);
 	if(userdb[user].twitterMode == MULTIPLECONTACT) {
 		tp->runAsThread(new FetchFriends(userdb[user].sessions, user, boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));
+	}

backends/twitter/TwitterPlugin.h

➞

Show inline comments

@@ @@ -65,48 +65,50 @@ class TwitterPlugin : public NetworkPlugin { @@
 		// 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 handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/);
 		void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/);
 		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 handleVCardRequest(const std::string &/*user*/, const std::string &/*legacyName*/, unsigned int /*id*/);
 		void pollForTweets();
 		void pollForDirectMessages();
 		bool getUserOAuthKeyAndSecret(const std::string user, std::string &key, std::string &secret);
 		bool checkSpectrum1User(const std::string user);
 		bool storeUserOAuthKeyAndSecret(const std::string user, const std::string OAuthKey, const std::string OAuthSecret);
 		void initUserSession(const std::string user, const std::string legacyName, 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);
 		void clearRoster(const std::string user);
 		int getTwitterMode(const std::string user);
 		bool setTwitterMode(const std::string user, int m);
 		/****************** Twitter response handlers **************************************/
 		void statusUpdateResponse(std::string &user, std::string &errMsg);
@@ @@ -132,41 +134,42 @@ class TwitterPlugin : public NetworkPlugin { @@
 	private:
 		enum status {NEW, WAITING_FOR_PIN, CONNECTED, DISCONNECTED};
 		enum mode {SINGLECONTACT, MULTIPLECONTACT, CHATROOM};
 		Config *config;
 		std::string adminLegacyName;
 		std::string adminChatRoom;
 		std::string adminNickName;
 		std::string adminAlias;
 		std::string consumerKey;
 		std::string consumerSecret;
 		std::string OAUTH_KEY;
 		std::string OAUTH_SECRET;
 		std::string MODE;
 		boost::mutex dblock, userlock;
 		ThreadPool *tp;
 		std::set<std::string> onlineUsers;
 		struct UserData
+		{
 			std::string legacyName;
 			bool spectrum1User; //Legacy support
 			User userTwitterObj;
 			std::string userImg;
 			twitCurl* sessions;
 			status connectionState;
 			std::string mostRecentTweetID;
 			std::string mostRecentDirectMessageID;
 			std::string nickName;
 			std::set<std::string> buddies;
 			std::map<std::string, User> buddiesInfo;
 			std::map<std::string, std::string> buddiesImgs;
 			mode twitterMode;
 			UserData() { sessions = NULL; }
 		};
 		std::map<std::string, UserData> userdb;
 };
 #endif

0 comments (0 inline, 0 general)