From 8a7660380b14c0e267fc718562a88484c1c88691 Mon Sep 17 00:00:00 2001
From: "Brian S. Stephan" <bss@incorporeal.org>
Date: Sat, 14 Jul 2012 09:29:12 -0500
Subject: [PATCH] Twitter: persist the authentication tokens and reuse them on
 init

---
 modules/Twitter.py | 84 ++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 77 insertions(+), 7 deletions(-)

diff --git a/modules/Twitter.py b/modules/Twitter.py
index 279af94..32adfeb 100644
--- a/modules/Twitter.py
+++ b/modules/Twitter.py
@@ -64,10 +64,29 @@ class Twitter(Module):
         self.consumer = oauth.Consumer(self.consumer_key, self.consumer_secret)
         self.client = oauth.Client(self.consumer)
 
-        # create a default twitter API account, in case we never auth
-        self.twit = twitter.Api()
-
+        # settings
         self.next_timeline_check = 0
+
+        # try getting the stored auth tokens and logging in
+        (oauth_token, oauth_token_secret) = self._retrieve_stored_auth_tokens()
+        if oauth_token is not None and oauth_token_secret is not None:
+            self._log_in_to_twitter(oauth_token, oauth_token_secret)
+            if self._verify_credentials():
+                # self.twit is set
+
+                # ugly, but the best place to track it. store the connection for later use
+                self.connection = irc
+
+                # print timeline stuff. this will set up the appropriate timer
+                self._check_self_timeline()
+
+                print("Logged in to Twitter with saved token.")
+            else:
+                print("Could not log in to Twitter with saved token.")
+                self.twit = twitter.Api()
+        else:
+            # create a default twitter API account, in case we never auth
+            self.twit = twitter.Api()
         thread.start_new_thread(self.thread_do, ())
 
     def db_init(self):
@@ -75,19 +94,37 @@ class Twitter(Module):
 
         # init the table if it doesn't exist
         version = self.db_module_registered(self.__class__.__name__)
-        if version == None:
+        if version == None or version < 1:
             # create tables
             db = self.get_db()
             try:
+                version = 1
+
                 db.execute("""
                     CREATE TABLE twitter_settings (
                         since_id INTEGER NOT NULL,
                         output_channel TEXT NOT NULL
                     )""")
                 db.execute("""INSERT INTO twitter_settings (since_id, output_channel) VALUES (0, '#drbotzo')""")
-                db.execute("INSERT INTO drbotzo_modules VALUES (?,?)", (self.__class__.__name__, 1))
                 db.commit()
                 db.close()
+                self.db_register_module_version(self.__class__.__name__, version)
+            except sqlite3.Error as e:
+                db.rollback()
+                db.close()
+                print("sqlite error: " + str(e))
+                raise
+        if version < 2:
+            db = self.get_db()
+            try:
+                version = 2
+
+                db.execute("""ALTER TABLE twitter_settings ADD COLUMN oauth_token TEXT DEFAULT NULL""")
+                db.execute("""ALTER TABLE twitter_settings ADD COLUMN oauth_token_secret TEXT DEFAULT NULL""")
+
+                db.commit()
+                db.close()
+                self.db_register_module_version(self.__class__.__name__, version)
             except sqlite3.Error as e:
                 db.rollback()
                 db.close()
@@ -269,8 +306,9 @@ class Twitter(Module):
         # create the twitter API object
         self.twit = twitter.Api(self.consumer_key, self.consumer_secret, oauth_token, oauth_token_secret)
 
-        #if self._verify_credentials() is not None:
-        #    # save the auth token for later reuse
+        if self._verify_credentials() is not None:
+            # save the auth token for later reuse
+            self._persist_auth_tokens(oauth_token, oauth_token_secret)
 
     def thread_do(self):
         """Check the timeline."""
@@ -395,5 +433,37 @@ class Twitter(Module):
 
         return latest
 
+    def _persist_auth_tokens(self, oauth_token, oauth_token_secret):
+        """Save the auth tokens to the database, with the intent of reusing them."""
+
+        try:
+            db = self.get_db()
+            cur = db.cursor()
+            statement = "UPDATE twitter_settings SET oauth_token = ?, oauth_token_secret = ?"
+            cur.execute(statement, (oauth_token, oauth_token_secret))
+            db.commit()
+            db.close()
+        except sqlite3.Error as e:
+            db.close()
+            print("sqlite error: " + str(e))
+            raise
+
+    def _retrieve_stored_auth_tokens(self):
+        """Check the database for existing auth tokens, try reusing them."""
+
+        try:
+            db = self.get_db()
+            query = "SELECT oauth_token, oauth_token_secret FROM twitter_settings"
+            cursor = db.execute(query)
+            result = cursor.fetchone()
+            db.close()
+            if result:
+                return (result['oauth_token'], result['oauth_token_secret'])
+        except sqlite3.Error as e:
+            db.close()
+            print("sqlite error: " + str(e))
+            raise
+
+
 # vi:tabstop=4:expandtab:autoindent
 # kate: indent-mode python;indent-width 4;replace-tabs on;