added basic telegram backend support

active_bots/telegrambot.py

@@ -0,0 +1,30 @@
+from bot import Bot
+import logging
+from report import Report
+from twx.botapi import TelegramBot
+
+
+logger = logging.getLogger(__name__)
+
+
+class TelegramBot(Bot):
+    def crawl(self, user):
+        tb = TelegramBot(user.get_telegram_credentials())
+        updates = tb.get_updates().wait()
+        reports = []
+        for update in updates:
+            reports.append(Report(update.message.from.username,self,
+                                  update.message.text,None,update.message.date))
+        return reports
+
+    def post(self, user, report):
+        tb = TelegramBot(user.get_telegram_credentials())
+        text = report.text
+        if len(text) > 4096:
+            text = text[:4096 - 4] + u' ...'
+        try:
+            for subscriber_id in user.get_telegram_subscribers():
+                tb.send_message(subscriber_id, text).wait()
+        except Exception:
+            logger.error('Error telegramming: ' + user.get_city() + ': '
+                         + report.id, exc_info=True)

db.py

@@ -108,6 +108,21 @@ class DB(object):
                 FOREIGN KEY(twitter_accounts_id)
                     REFERENCES twitter_accounts(id)
             );
+            CREATE TABLE IF NOT EXISTS telegram_accounts (
+                id          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE,
+                user_id     INTEGER,
+                api_token   TEXT,
+                active      INTEGER,
+                FOREIGN KEY(user_id) REFERENCES user(id)
+            );
+            CREATE TABLE IF NOT EXISTS telegram_subscribers (
+                id          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE,
+                user_id     INTEGER,
+                subscriber_id   INTEGER,
+                active      INTEGER,
+                FOREIGN KEY(user_id) REFERENCES user(id),
+                UNIQUE(user_id, subscriber_id) ON CONFLICT IGNORE
+            );
             CREATE TABLE IF NOT EXISTS mailinglist (
                 id          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE,
                 user_id     INTEGER,

user.py

@@ -23,6 +23,7 @@ class User(object):
         db.execute("UPDATE user SET passhash=? WHERE id=?;",
                    (passhash, self.uid))
         db.commit()
+
     password = property(None, password)  # setter only, can't read back
 
     @property
@@ -73,11 +74,52 @@ class User(object):
                 return False
         return True
 
-    def get_masto_credentials(self):
+    def get_telegram_credentials(self):
-        db.execute("SELECT access_token, instance_id FROM mastodon_accounts WHERE user_id = ? AND active = 1;",
+        db.execute("""SELECT api_token 
+                          FROM telegram_accounts 
+                          WHERE user_id = ? AND active = 1;""",
                    (self.uid,))
         row = db.cur.fetchone()
-        db.execute("SELECT instance, client_id, client_secret FROM mastodon_instances WHERE id = ?;",
+        return row[0]
+
+    def save_telegram_credentials(self, api_token):
+        db.execute("""INSERT INTO telegram_accounts (
+                          user_id, api_token, active) VALUES(?, ?, 1);""",
+                   (self.uid, api_token))
+        db.commit()
+
+
+    def get_telegram_subscribers(self):
+        db.execute("""SELECT subscriber_id 
+                          FROM telegram_subscribers 
+                          WHERE user_id = ? AND active = 1;""",
+                   (self.uid,))
+        rows = db.cur.fetchall()
+        return rows
+
+    def add_telegram_subscribers(self, subscriber_id):
+        db.execute("""INSERT INTO telegram_subscribers (
+                            user_id, subscriber_id) VALUES(?, ?);""",
+                   (self.uid, subscriber_id))
+        db.commit()
+
+    def remove_telegram_subscribers(self, subscriber_id):
+        db.execute("""DELETE 
+                          FROM telegram_subscribers 
+                          WHERE user_id = ?
+                          AND subscriber_id = ?;""",
+                   (self.uid, subscriber_id))
+        db.commit()
+
+    def get_masto_credentials(self):
+        db.execute("""SELECT access_token, instance_id 
+                          FROM mastodon_accounts 
+                          WHERE user_id = ? AND active = 1;""",
+                   (self.uid,))
+        row = db.cur.fetchone()
+        db.execute("""SELECT instance, client_id, client_secret 
+                          FROM mastodon_instances 
+                          WHERE id = ?;""",
                    (row[1],))
         instance = db.cur.fetchone()
         return instance[1], instance[2], row[0], instance[0]
@@ -118,11 +160,14 @@ class User(object):
                    (tweet_id, self.uid))
 
     def get_mailinglist(self):
-        db.execute("SELECT email FROM mailinglist WHERE user_id = ? AND active = 1;", (self.uid, ))
+        db.execute("""SELECT email 
+                          FROM mailinglist 
+                          WHERE user_id = ? AND active = 1;""", (self.uid,))
         return db.cur.fetchone()[0]
 
     def get_seen_mail(self):
-        db.execute("SELECT mail_date FROM seen_mails WHERE user_id = ?;", (self.uid, ))
+        db.execute("""SELECT mail_date 
+                          FROM seen_mails WHERE user_id = ?;""", (self.uid,))
         return db.cur.fetchone()[0]
 
     def save_seen_mail(self, mail_date):
@@ -130,38 +175,50 @@ class User(object):
                    (mail_date, self.uid))
 
     def get_trigger_words(self, table):
-        db.execute("SELECT words FROM ? WHERE user_id = ?;", (table, self.uid,))
+        db.execute("""SELECT words 
+                          FROM ? WHERE user_id = ?;""", (table, self.uid,))
         return db.cur.fetchone()[0]
 
     def state(self):
         return dict(foo='bar')
 
     def save_request_token(self, token):
-        db.execute("INSERT INTO twitter_request_tokens(user_id, request_token, request_token_secret) VALUES(?, ?, ?);",
+        db.execute("""INSERT INTO
-                   (self.uid, token["oauth_token"], token["oauth_token_secret"]))
+                          twitter_request_tokens(
+                              user_id, request_token, request_token_secret
+                          ) VALUES(?, ?, ?);""",
+                   (self.uid, token["oauth_token"],
+                    token["oauth_token_secret"]))
         db.commit()
 
     def get_request_token(self):
-        db.execute("SELECT request_token, request_token_secret FROM twitter_request_tokens WHERE user_id = ?;", (self.uid,))
+        db.execute("""SELECT request_token, request_token_secret 
+                          FROM twitter_request_tokens 
+                          WHERE user_id = ?;""", (self.uid,))
         request_token = db.cur.fetchone()
-        db.execute("DELETE FROM twitter_request_tokens WHERE user_id = ?;", (self.uid,))
+        db.execute("""DELETE FROM twitter_request_tokens 
+                          WHERE user_id = ?;""", (self.uid,))
         db.commit()
         return {"oauth_token": request_token[0],
                 "oauth_token_secret": request_token[1]}
 
     def save_twitter_token(self, access_token, access_token_secret):
-        db.execute(
+        db.execute(""""INSERT INTO twitter_accounts(
-            "INSERT INTO twitter_accounts(user_id, client_id, client_secret) VALUES(?, ?, ?);",
+                           user_id, client_id, client_secret
+                           ) VALUES(?, ?, ?);""",
                    (self.uid, access_token, access_token_secret))
         db.commit()
 
     def get_twitter_token(self):
-        db.execute("SELECT access_token, access_token_secret FROM twitter_accouts WHERE user_id = ?;",
+        db.execute("""SELECT access_token, access_token_secret 
+                          FROM twitter_accouts WHERE user_id = ?;""",
                    (self.uid,))
         return db.cur.fetchall()
 
     def get_mastodon_app_keys(self, instance):
-        db.execute("SELECT client_id, client_secret FROM mastodon_instances WHERE instance = ?;", (instance, ))
+        db.execute("""SELECT client_id, client_secret 
+                          FROM mastodon_instances 
+                          WHERE instance = ?;""", (instance,))
         try:
             row = db.cur.fetchone()
             client_id = row[0]
@@ -169,14 +226,19 @@ class User(object):
             return client_id, client_secret
         except TypeError:
             app_name = "ticketfrei" + str(db.secret)[0:4]
-            client_id, client_secret = Mastodon.create_app(app_name, api_base_url=instance)
+            client_id, client_secret \
-            db.execute("INSERT INTO mastodon_instances(instance, client_id, client_secret) VALUES(?, ?, ?);",
+                = Mastodon.create_app(app_name, api_base_url=instance)
+            db.execute("""INSERT INTO mastodon_instances(
+                              instance, client_id, client_secret
+                              ) VALUES(?, ?, ?);""",
                        (instance, client_id, client_secret))
             db.commit()
             return client_id, client_secret
 
     def save_masto_token(self, access_token, instance):
-        db.execute("SELECT id FROM mastodon_instances WHERE instance = ?;", (instance, ))
+        db.execute("""SELECT id 
+                          FROM mastodon_instances 
+                          WHERE instance = ?;""", (instance,))
         instance_id = db.cur.fetchone()[0]
         db.execute("INSERT INTO mastodon_accounts(user_id, access_token, instance_id, active) "
                    "VALUES(?, ?, ?, ?);", (self.uid, access_token, instance_id, 1))