reddit-to-telegram 0.8.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d1bb9660df8f6218a7bcbbbaa14b7e334fca34806c6923db6342ec41d6b44bb
-  data.tar.gz: 3adf418255edb66a94efd73cb08a603570ad72278fe6ab45177a7ff64232385b
+  metadata.gz: 00436ff5f5d09c81d76f4d49f3cc3996e983857f1fbff2ad2db006ea014c0e96
+  data.tar.gz: ca6e585387a1165a9dacdee453d4853e531b727f9498918c97675d9484275b6c
 SHA512:
-  metadata.gz: 616ec4f213bc2d759aff599a6260f86d131173353e329a911ee4287082ec7b0b29f2dec1a2b3db19cc6da22b3c1c13b9e339db293411ffb43d9b2879a30fba47
-  data.tar.gz: d401484d93b7ae2e5537074e3c72219b1b267ad29a5e49cd0d944361654a6808d2f7f3df36123d05805c4e213be78f522cbd67623c6ff1d99dfdad0466986df2
+  metadata.gz: e2ff22eb616b95a99f3046b0c63677f24f7ca0ee1327bb7a51e97a68190b9c39639562024efaca73afa292b24b05188d9abaedba74de491bf708606526895519
+  data.tar.gz: 8658836ee6bb761ff2c75f9cd7c11ea2c2f526604982933d48eced8edf31ac515b8ca3ed97ac34bb515dca7baa21cb3d5de10463e13268519d3b73f8293be8f0

data/.rubocop.yml

@@ -1,3 +1,6 @@
+Metrics/ClassLength:
+  Max: 150
+
 Metrics/MethodLength:
   Max: 20
 

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    reddit-to-telegram (0.5.1)
-      aws-sdk-simpledb
+    reddit-to-telegram (0.10.0)
+      aws-sdk-dynamodb (~> 1.106)
       httparty
 
 GEM
@@ -11,15 +11,14 @@ GEM
     ast (2.4.2)
     aws-eventstream (1.3.0)
     aws-partitions (1.883.0)
-    aws-sdk-core (3.190.3)
+    aws-sdk-core (3.192.1)
       aws-eventstream (~> 1, >= 1.3.0)
       aws-partitions (~> 1, >= 1.651.0)
       aws-sigv4 (~> 1.8)
       jmespath (~> 1, >= 1.6.1)
-    aws-sdk-simpledb (1.42.0)
-      aws-sdk-core (~> 3, >= 3.188.0)
-      aws-sigv2 (~> 1.0)
-    aws-sigv2 (1.2.0)
+    aws-sdk-dynamodb (1.106.0)
+      aws-sdk-core (~> 3, >= 3.191.0)
+      aws-sigv4 (~> 1.1)
     aws-sigv4 (1.8.0)
       aws-eventstream (~> 1, >= 1.0.2)
     httparty (0.21.0)

data/README.md

@@ -7,7 +7,7 @@
 Beware, this is remotely not production-ready, API will change, you'll see lots of bugs and it may break at any time.
 Be sure to check for gem updates.
 
-You can set this bot up absolutely for free [via AWS Lambda](https://gist.github.com/dersnek/851c32a6b45eab19f1c8748095b2a481#file-free-rtt-bot-in-aws-lambda).
+You can set this bot up absolutely for free [via AWS Lambda](https://gist.github.com/dersnek/851c32a6b45eab19f1c8748095b2a481#file-free-rtt-bot-in-aws-lambda), no ruby knowledge required.
 
 ## Installation
 In your `Gemfile` add:
@@ -19,33 +19,33 @@ Then run `bundle install`.
 Or `gem install reddit-to-telegram`. Don't forget to `require` it.
 
 ## Prerequisites
-- (Optionally) You'll need an [AWS account](https://aws.amazon.com/) to host a free SimpleDB (best available storage type, also default one). I also recommend hosting the bot on AWS lambda, since it would be free.
-- (Optionally) [Create a Reddit app](https://www.reddit.com/prefs/apps), which would allow more requests to reddit
 - [Obtain a telegram bot token](https://core.telegram.org/bots/tutorial#obtain-your-bot-token)
+- (Optionally) You'll need an [AWS account](https://aws.amazon.com/) to host a free DynamoDB (best available storage type, also default one). I also recommend hosting the bot on AWS lambda, since it would be free.
+- (Optionally) [Create a Reddit app](https://www.reddit.com/prefs/apps), which would allow more requests to reddit
 
-To run it, you'll need some env variables set.
-| Variable Name                 | Description                                                                                                                                                                   | Required |
-| -------------                 | -----------                                                                                                                                                                   | -------- |
-| RTT_AWS_ACCESS_KEY_ID         | Your AWS access key ID. Needed for AWS SimpleDB storage                                                                                                                       | No       |
-| RTT_AWS_DOMAIN_NAME           | Domain name to use for SimpleDB                                                                                                                                               | No       |
-| RTT_AWS_REGION                | AWS region your SimpleDB will be hosted on. Beware, it's not available in all regions.                                                                                        | No       |
-| RTT_AWS_SECRET_ACCESS_KEY     | Your AWS access key ID. Needed for AWS SimpleDB storage.                                                                                                                      | No       |
-| RTT_GOOGLE_API_KEY            | Your Google API key to translate posts via Google Translate.                                                                                                                  | No       |
-| RTT_MAX_STORED_POSTS          | Number of posts to store in the database to avoid duplicates, default is 25.                                                                                                  | No       |
-| RTT_REDDIT_CLIENT_ID          | Reddit app credentials to access API. Reddit allows more authenticated requests.                                                                                              | No       |
-| RTT_REDDIT_CLIENT_SECRET      | Reddit app credentials to access API. Reddit allows more authenticated requests.                                                                                              | No       |
-| RTT_STORE_TYPE                | Choose between `aws_simple_db`, `memory` or `temp_file`. Default is `aws_simple_db`, so if you're not specifying your AWS credentials, you have to choose another store type. | No       |
-| RTT_TELEGRAM_BOT_TOKEN        | The token you've received when you've created a telegram bot.                                                                                                                 | Yes      |
-| RTT_TELEGRAM_ERROR_CHANNEL_ID | Telegram channel to send errors to (without `@`, only errors from Telegram API responses would be sent for now)                                                               | No       |
-| RTT_TEMP_DIR                  | Directory to write temp files to without trailing `/`                                                                                                                         | No       |
+It is pretty congifurable, either dynamically or via ENV variables.
+To assign variables dynamically, set them via `RedditToTelegram.config.variable_name= `, e.g. `RedditToTelegram.config.aws.access_key_id = ...`.
+You can also create an ENV variable with a corresponding name. Here is the full configuration explained. Required options have a * next to them.
 
-
-You can also set them dynamically:
-```
-RedditToTelegram.config.aws.access_key_id =
-RedditToTelegram.config.telegram.bot_token =
-```
-Check out `lib/configuration` for full configuration.
+Config variable           | Corresponding ENV Variable    | Description                                                                                                                                                                  |
+| ----------------------- | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+add_channel_handle        | -                             | Add channel handle to Telegram posts. Accepted values: true or false. Default is false                                                                                       |
+add_reddit_link           | -                             | Add reddit link to Telegram posts. Accepted values: true or false. Default is false.                                                                                         |
+logger                    | -                             | Which logger to use. You can pass your own ruby logger                                                                                                                       |
+on_error                  | -                             | What to do when an error happens. Default is :log, but you can also :raise or :ignore                                                                                        |
+send_errors_to_telegram   | -                             | Also log errors to telegram (besides regular logging). Accepted values: true or false, default is false                                                                      |
+translate                 | -                             | Translate posts via Google Translate. Leave empty for no translation. More details below                                                                                     |
+aws.access_key_id         | RTT_AWS_ACCESS_KEY_ID         | Your AWS access key ID. Needed for AWS DynamoDB storage                                                                                                                      |
+aws.region                | RTT_AWS_REGION                | AWS region your DynamoDB is hosted on                                                                                                                                        |
+aws.secret_access_key     | RTT_AWS_SECRET_ACCESS_KEY     | Your AWS access key ID. Needed for AWS DynamoDB storage.                                                                                                                     |
+google.api_key            | RTT_GOOGLE_API_KEY            | Your Google API key to translate posts via Google Translate                                                                                                                  |
+reddit.client_id          | RTT_REDDIT_CLIENT_ID          | Reddit app credentials to access API. Reddit allows more authenticated requests                                                                                              |
+reddit.client_secret      | RTT_REDDIT_CLIENT_SECRET      | Reddit app credentials to access API. Reddit allows more authenticated requests                                                                                              |
+store.max_stored_posts    | RTT_MAX_STORED_POSTS          | Number of posts to store in the database to avoid duplicates, default is 25                                                                                                  |
+store.tmp_dir             | RTT_TEMP_DIR                  | Directory to write temp files to without trailing `/`                                                                                                                        |
+store.type                | RTT_STORE_TYPE                | Choose between `aws_dynamo_db`, `memory` or `temp_file`. Default is `aws_dynamo_db`, so if you're not specifying your AWS credentials, you have to choose another store type |
+telegram.bot_token *      | RTT_TELEGRAM_BOT_TOKEN        | The token you've received when you've created a telegram bot                                                                                                                 |
+telegram.error_channel_id | RTT_TELEGRAM_ERROR_CHANNEL_ID | Telegram channel to send errors to (without `@`, only errors from Telegram API responses would be sent for now)                                                              |
 
 ## Usage
 
@@ -53,30 +53,19 @@ Check out `lib/configuration` for full configuration.
 2. To fetch latest hot post which hasn't been pushed yet:
 ```
 RedditToTelegram.hot(
-    subreddit_name_1: :telegram_channel_id_1,
-    subreddit_name_2: :telegram_channel_id_2
+    telegram_channel_id_1: :subreddit_name_1,
+    telegram_channel_id_2: :subreddit_name_2
   )
 ```
-Or to push one specific post (the only thing you need to set up for this is your telegram bot token):
+You can push posts from one subreddit to one telegram channel, several-to-one, one-to-several, several-to-several, whatever you like.
+You can also push one specific post:
 ```
-RedditToTelegram.from_link("regular_link_to_post", :telegram_channel_id)
+RedditToTelegram.from_link(telegram_channel_id: "regular_link_to_post")
 ```
 Use `:telegram_channel_id` without the `@`.
 
-### Options
+### Translation
 
-Translate option is supported. You will have to set up Google Translate API key and add it to env. You can find available languages in [Google Translate docs](https://cloud.google.com/translate/docs/languages).
-```
-RedditToTelegram.hot(
-    { subreddit_name_1: :telegram_channel_id_1 },
-    translate: :ja
-  )
-```
-You can also specify if you want to add reddit link or telegram channel handle to the post text. By default they won't be added.
-```
-RedditToTelegram.hot(
-    { subreddit_name_1: :telegram_channel_id_1 },
-    add_reddit_link: true,
-    add_channel_handle: true
-  )
-```
+Translation option is supported.
+You will have to set `RedditToTelegram.config.translate` to the language key you want to translate to. You can find available languages in [Google Translate docs](https://cloud.google.com/translate/docs/languages).
+You will also have to set up Google Translate API key assign it to `RedditToTelegram.config.google.api_key`.

data/lib/reddit-to-telegram.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "reddit_to_telegram/configuration"
 Dir["#{File.dirname(__FILE__)}/reddit_to_telegram/**/*.rb"].each { |file| require file }
 
 module RedditToTelegram

data/lib/reddit_to_telegram/configuration.rb

@@ -5,7 +5,16 @@ require "logger"
 module RedditToTelegram
   module Configuration
     class << self
-      attr_writer :logger, :on_error
+      attr_writer :add_channel_handle, :add_reddit_link, :logger,
+                  :on_error, :send_errors_to_telegram, :translate
+
+      def add_channel_handle
+        @add_channel_handle ||= false
+      end
+
+      def add_reddit_link
+        @add_reddit_link ||= false
+      end
 
       def logger
         @logger ||= Logger.new($stdout).tap do |log|
@@ -16,11 +25,19 @@ module RedditToTelegram
       def on_error
         @on_error ||= :log
       end
+
+      def send_errors_to_telegram
+        @send_errors_to_telegram ||= false
+      end
+
+      def translate
+        @translate ||= nil
+      end
     end
 
     class Store
       DEFAULT_TMP_DIR = "#{Dir.pwd}/tmp".freeze
-      DEFAULT_TYPE = :aws_simple_db
+      DEFAULT_TYPE = :aws_dynamo_db
 
       class << self
         attr_writer :max_stored_posts, :tmp_dir, :type
@@ -40,8 +57,7 @@ module RedditToTelegram
     end
 
     class AWS
-      ATTRS = %i[access_key_id secret_access_key region domain_name].freeze
-      DEFAULT_DOMAIN_NAME = "reddit_to_telegram"
+      ATTRS = %i[access_key_id secret_access_key region].freeze
 
       class << self
         attr_writer(*ATTRS)
@@ -58,10 +74,6 @@ module RedditToTelegram
           @region ||= ENV["RTT_AWS_REGION"]
         end
 
-        def domain_name
-          @domain_name ||= ENV["RTT_AWS_DOMAIN_NAME"] || DEFAULT_DOMAIN_NAME
-        end
-
         def set_up?
           ATTRS.all? { |a| !a.to_s.empty? }
         end

data/lib/reddit_to_telegram/errors.rb

@@ -3,19 +3,50 @@
 module RedditToTelegram
   class RedditToTelegramError < StandardError; end
 
+  class BadResponseFromTelegram < RedditToTelegramError; end
+  class FailedToCreateDatabaseTable < RedditToTelegramError; end
+  class FailedToFetchFromReddit < RedditToTelegramError; end
+  class FailedToPersistData < RedditToTelegramError; end
   class InvalidStoreType < RedditToTelegramError; end
   class MissingConfiguration < RedditToTelegramError; end
 
   class Errors
     class << self
       def new(error, message = nil)
+        log_message = error.to_s
+        log_message += ": #{message}" unless message.nil?
+
         if Configuration.on_error == :raise
           raise(error.new(message))
         elsif Configuration.on_error == :log
-          log_message = error.to_s
-          log_message += ": #{message}" unless message.nil?
           Configuration.logger.error(log_message)
         end
+
+        return unless Configuration.send_errors_to_telegram
+
+        push_error_to_telegram(log_message)
+
+        nil
+      end
+
+      private
+
+      def push_error_to_telegram(message)
+        if Configuration.telegram.error_channel_id.to_s.empty?
+          Configuration.logger.warn("Telegram Error Channel ID is not set up, can't send errors there")
+          return
+        end
+
+        Telegram::Post.push(
+          {
+            type: :text,
+            text: message,
+            misc: { no_retry: true, disable_link_preview: true }
+          },
+          Configuration.telegram.error_channel_id
+        )
+
+        nil
       end
     end
   end

data/lib/reddit_to_telegram/post.rb

@@ -3,29 +3,29 @@
 module RedditToTelegram
   class Post
     class << self
-      def hot(sources, opts = {})
+      def hot(sources)
         check_config
-        return if sources.empty?
-
         Store.setup
 
-        sources.each do |subreddit, telegram_chat_id|
-          res = Reddit::Fetch.hot(subreddit)
-          handle_res(res, subreddit, telegram_chat_id, opts)
+        sources.each do |telegram_chat_id, subreddits|
+          Array(subreddits).each do |subreddit|
+            res = Reddit::Fetch.hot(subreddit)
+            handle_res(res, subreddit, telegram_chat_id)
+          end
         end
       end
 
-      def from_link(link, telegram_chat_id, opts = {})
+      def from_link(sources)
         check_config
-        return if link.empty?
+        return unless check_from_link_sources(sources)
 
         Configuration.store.type = :memory
         Store.setup
 
-        res = Reddit::Fetch.post(link)
+        res = Reddit::Fetch.post(sources.values.first)
         return unless res_ok?(res)
 
-        Telegram::Post.push(res, telegram_chat_id, opts)
+        Telegram::Post.push(res, sources.keys.first)
         res
       end
 
@@ -35,19 +35,17 @@ module RedditToTelegram
         Errors.new(MissingConfiguration, "Missing Telegram bot token") if Configuration.telegram.bot_token.to_s.empty?
       end
 
-      def handle_res(res, subreddit, telegram_chat_id, opts = {})
+      def handle_res(res, subreddit, telegram_chat_id)
         return unless res_ok?(res)
 
-        post = find_new_post(subreddit, res)
+        post = Store.posts.next(telegram_chat_id, subreddit, res)
 
         if post.nil?
           Configuration.logger.info("Could not find a new post to push")
           return
         end
 
-        res = Telegram::Post.push(post, telegram_chat_id, opts)
-        Store::Posts.add(subreddit, post[:id])
-        res
+        Telegram::Post.push(post, telegram_chat_id)
       end
 
       def res_ok?(res)
@@ -62,8 +60,13 @@ module RedditToTelegram
         end
       end
 
-      def find_new_post(subreddit, posts)
-        posts.find { |post| !Store::Posts.dup?(subreddit, post[:id]) }
+      def check_from_link_sources(sources)
+        if !sources.is_a?(Hash) || sources.keys.count != 1 || sources.values.count != 1
+          Errors.new(ArgumentError, "Check documentation on usage")
+          return false
+        end
+
+        true
       end
     end
   end

data/lib/reddit_to_telegram/reddit/fetch.rb

@@ -55,12 +55,22 @@ module RedditToTelegram
             handle_429(func_name, func_args)
           when 200
             Output.format_response(res)
+          else
+            Errors.new(FailedToFetchFromReddit, res.to_s)
           end
         end
 
         def handle_401(func_name, func_args)
+          retries_left = func_args.last
+          func_args[func_args.length - 1] = retries_left - 1
+
           Store::Reddit.token = Auth.token
-          send(func_name, *func_args) if func_args.last > 0
+
+          if retries_left > 0
+            send(func_name, *func_args)
+          else
+            Errors.new(FailedToFetchFromReddit, "Failed to authenticate")
+          end
         end
 
         def handle_429(func_name, func_args)
@@ -68,7 +78,12 @@ module RedditToTelegram
 
           sleep(10 / retries_left) if retries_left > 0
           func_args[func_args.length - 1] = retries_left - 1
-          send(func_name, *func_args) if retries_left > 0
+
+          if retries_left > 0
+            send(func_name, *func_args)
+          else
+            Errors.new(FailedToFetchFromReddit, "Too many requests")
+          end
         end
       end
     end

data/lib/reddit_to_telegram/reddit/output.rb

@@ -96,8 +96,9 @@ module RedditToTelegram
         end
 
         def base_post_format_attrs(data)
-          { id: data["name"],
-            text: CGI.unescapeHTML(data["title"]) }
+          { id: data["name"].split("_")&.dig(1),
+            text: CGI.unescapeHTML(data["title"]),
+            misc: {} }
         end
 
         def prepare_gallery_links(data)

data/lib/reddit_to_telegram/store/aws_dynamo_db.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "aws-sdk-dynamodb"
+require "json"
+
+module RedditToTelegram
+  module Store
+    class AWSDynamoDB
+      ITEM_NAME = "cached_data"
+
+      class << self
+        def client
+          @client ||= Aws::DynamoDB::Client.new(
+            access_key_id: Configuration.aws.access_key_id,
+            secret_access_key: Configuration.aws.secret_access_key,
+            region: Configuration.aws.region
+          )
+        end
+
+        private
+
+        attr_reader :reddit_token
+
+        def setup
+          check_credentials
+          prepare_db
+          assign_default_values
+        end
+
+        def check_credentials
+          return unless Configuration.store.type == :aws_dynamo_db
+
+          return if Configuration.aws.set_up?
+
+          Errors.new(
+            MissingConfiguration,
+            "Missing AWS credentials. Set them up or change store type to anything other than aws_dynamo_db"
+          )
+        end
+
+        def add_post(telegram_chat_id, subreddit, id)
+          assign_empty_values_to_posts(telegram_chat_id, subreddit)
+
+          @posts[telegram_chat_id][subreddit] << id
+
+          if @posts[telegram_chat_id][subreddit].count > Store.max_stored_posts
+            @posts[telegram_chat_id][subreddit].shift
+          end
+
+          persist_posts(telegram_chat_id)
+        end
+
+        def assign_empty_values_to_posts(telegram_chat_id, subreddit)
+          @posts[telegram_chat_id] = {} if @posts[telegram_chat_id].nil?
+          @posts[telegram_chat_id][subreddit] = [] if @posts[telegram_chat_id][subreddit].nil?
+        end
+
+        def persist_posts(telegram_chat_id)
+          res = client.put_item(
+            {
+              item: {
+                "TelegramChannel" => telegram_chat_id.to_s,
+                "Posts" => @posts[telegram_chat_id].to_json
+              },
+              return_consumed_capacity: "TOTAL",
+              table_name: POSTS_TABLE_NAME
+            }
+          )
+
+          Errors.new(FailedToPersistData, "Failed to persist data to DynamoDB") unless res.successful?
+        end
+
+        def dup_post?(telegram_chat_id, subreddit, id)
+          return false if @posts.dig(telegram_chat_id, subreddit).nil?
+
+          @posts[telegram_chat_id][subreddit].include?(id)
+        end
+
+        def load_posts(telegram_chat_id)
+          res = client.get_item(
+            { key: { "TelegramChannel" => telegram_chat_id.to_s },
+              table_name: POSTS_TABLE_NAME }
+          )
+          @posts[telegram_chat_id] = JSON.parse(res.item["Posts"]).transform_keys(&:to_sym)
+        rescue StandardError
+          @posts[telegram_chat_id] = nil
+        end
+
+        def assign_default_values
+          @reddit_token = ""
+          @posts = {}
+        end
+
+        POSTS_TABLE_NAME = "Posts"
+        POSTS_TABLE_ATTRIBUTES = {
+          attribute_definitions: [
+            { attribute_name: "TelegramChannel",
+              attribute_type: "S" }
+          ],
+          key_schema: [
+            { attribute_name: "TelegramChannel",
+              key_type: "HASH" }
+          ],
+          provisioned_throughput: {
+            read_capacity_units: 1,
+            write_capacity_units: 1
+          },
+          table_name: POSTS_TABLE_NAME
+        }.freeze
+
+        def prepare_db
+          res = client.list_tables
+          return unless res.successful?
+
+          return if res.table_names.include?(POSTS_TABLE_NAME)
+
+          client.create_table(POSTS_TABLE_ATTRIBUTES)
+
+          waited = 0
+          while client.describe_table(table_name: POSTS_TABLE_NAME).table.table_status != "ACTIVE"
+            if waited == 10
+              Errors.new(FailedToCreateDatabaseTable, "Failed to create #{POSTS_TABLE_NAME} table in DynamoDB")
+              break
+            end
+            sleep(1)
+            waited += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/store/memory.rb

@@ -11,17 +11,26 @@ module RedditToTelegram
         @posts = {}
 
         def setup; end
+        def load_posts(_); end
 
-        def add_post(subreddit, id)
-          @posts[subreddit] = [] if @posts[subreddit].nil?
-          @posts[subreddit] << id
-          @posts[subreddit].shift if @posts[subreddit].count > Store::MAX_STORED_POSTS
+        def add_post(telegram_chat_id, subreddit, id)
+          assign_empty_values_to_posts(telegram_chat_id, subreddit)
+
+          posts[telegram_chat_id][subreddit] << id
+          return unless posts[telegram_chat_id][subreddit].count > Store.max_stored_posts
+
+          posts[telegram_chat_id][subreddit].shift
+        end
+
+        def assign_empty_values_to_posts(telegram_chat_id, subreddit)
+          posts[telegram_chat_id] = {} if posts[telegram_chat_id].nil?
+          posts[telegram_chat_id][subreddit] = [] if posts[telegram_chat_id][subreddit].nil?
         end
 
-        def dup_post?(subreddit, id)
-          return false if posts[subreddit].nil?
+        def dup_post?(telegram_channel, subreddit, id)
+          return false if posts.dig(telegram_channel, subreddit).nil?
 
-          posts[subreddit].include?(id)
+          posts[telegram_channel][subreddit].include?(id)
         end
 
         def posts

data/lib/reddit_to_telegram/store/temp_file.rb

@@ -17,22 +17,34 @@ module RedditToTelegram
           read_file
         end
 
+        def load_posts(_); end
+
         def reddit_token=(val)
           @reddit_token = val
           write_file
         end
 
-        def add_post(subreddit, id)
-          @posts[subreddit] = [] if @posts[subreddit].nil?
-          @posts[subreddit] << id
-          @posts[subreddit].shift if @posts[subreddit].count > Store::MAX_STORED_POSTS
+        def add_post(telegram_chat_id, subreddit, id)
+          assign_empty_values_to_posts(telegram_chat_id, subreddit)
+
+          @posts[telegram_chat_id][subreddit] << id
+
+          if @posts[telegram_chat_id][subreddit].count > Store.max_stored_posts
+            @posts[telegram_chat_id][subreddit].shift
+          end
+
           write_file
         end
 
-        def dup_post?(subreddit, id)
-          return false if posts[subreddit].nil?
+        def assign_empty_values_to_posts(telegram_chat_id, subreddit)
+          @posts[telegram_chat_id] = {} if @posts[telegram_chat_id].nil?
+          @posts[telegram_chat_id][subreddit] = [] if @posts[telegram_chat_id][subreddit].nil?
+        end
+
+        def dup_post?(telegram_channel, subreddit, id)
+          return false if posts.dig(telegram_channel, subreddit).nil?
 
-          posts[subreddit].include?(id)
+          posts[telegram_channel][subreddit].include?(id)
         end
 
         def read_file
@@ -43,14 +55,14 @@ module RedditToTelegram
           @reddit_token = data["reddit_token"]
           @posts = {}
           data.each do |key, value|
-            @posts[key.split("_").last.to_sym] = value if key.match?(/posts_.+/)
+            @posts[key.split("_").last.to_sym] = value.transform_keys(&:to_sym) if key.match?(/posts_.+/)
           end
         end
 
         def write_file
           data = { reddit_token: @reddit_token }
-          @posts.each do |subreddit, values|
-            data["posts_#{subreddit}".to_sym] = values
+          @posts.each do |telegram_chat_id, values|
+            data["posts_#{telegram_chat_id}"] = values
           end
           File.open(temp_file_path, "w") { |f| f.write(data.to_json) }
         end

data/lib/reddit_to_telegram/store.rb

@@ -2,15 +2,12 @@
 
 module RedditToTelegram
   module Store
-    MAX_STORED_POSTS = Configuration.store.max_stored_posts - 1
     CLASS_MAP = {
-      aws_simple_db: "RedditToTelegram::Store::AWSSimpleDB",
+      aws_dynamo_db: "RedditToTelegram::Store::AWSDynamoDB",
       memory: "RedditToTelegram::Store::Memory",
       temp_file: "RedditToTelegram::Store::TempFile"
     }.freeze
 
-    STORE = Object.const_get("RedditToTelegram::Store::AWSSimpleDB")
-
     class << self
       attr_accessor :active
 
@@ -20,6 +17,18 @@ module RedditToTelegram
         self.active = Object.const_get(CLASS_MAP[Configuration.store.type])
         active.send(:setup)
       end
+
+      def max_stored_posts
+        Configuration.store.max_stored_posts - 1
+      end
+
+      def reddit
+        Reddit
+      end
+
+      def posts
+        Posts
+      end
     end
 
     class Reddit
@@ -36,12 +45,19 @@ module RedditToTelegram
 
     class Posts
       class << self
-        def add(subreddit, id)
-          Store.active.send(:add_post, subreddit, id)
+        def add(telegram_chat_id, subreddit, id)
+          Store.active.send(:add_post, telegram_chat_id, subreddit, id)
+        end
+
+        def dup?(telegram_chat_id, subreddit, id)
+          Store.active.send(:dup_post?, telegram_chat_id, subreddit, id)
         end
 
-        def dup?(subreddit, id)
-          Store.active.send(:dup_post?, subreddit, id)
+        def next(telegram_chat_id, subreddit, posts)
+          Store.active.send(:load_posts, telegram_chat_id)
+          new_post = posts.find { |post| !dup?(telegram_chat_id, subreddit, post[:id]) }
+          add(telegram_chat_id, subreddit, new_post[:id]) unless new_post.nil?
+          new_post
         end
       end
     end

data/lib/reddit_to_telegram/telegram/post/gallery.rb

@@ -5,30 +5,30 @@ module RedditToTelegram
     class Post
       class Gallery
         class << self
-          def push_remaining_gallery_data(post, channel, res, opts = {})
+          def push_remaining_gallery_data(post, channel, res)
             if post[:additional_media]
-              push_remaining_gallery_images(post, channel, opts)
+              push_remaining_gallery_images(post, channel)
             else
-              push_gallery_caption(post, channel, res, opts)
+              push_gallery_caption(post, channel, res)
             end
           end
 
           private
 
-          def push_remaining_gallery_images(post, channel,opts = {})
+          def push_remaining_gallery_images(post, channel)
             post[:media] = post[:additional_media].first(10)
             remaining = post.delete(:additional_media).drop(10)
             post[:additional_media] = remaining unless remaining.empty?
-            Post.push(post, channel, opts)
+            Post.push(post, channel)
           end
 
-          def push_gallery_caption(post, channel, res, opts = {})
+          def push_gallery_caption(post, channel, res)
             Telegram::Post.push(
               { type: :text,
                 id: post[:id],
-                text: post[:text] },
-              channel,
-              opts.merge(gallery_caption_opts(res))
+                text: post[:text],
+                misc: gallery_caption_opts(res) },
+              channel
             )
           end
 

data/lib/reddit_to_telegram/telegram/post.rb

@@ -19,20 +19,20 @@ module RedditToTelegram
       }.freeze
 
       class << self
-        def push(post, channel, opts = {})
+        def push(post, channel)
           res = HTTParty.post(
             "#{BASE_URI}#{Configuration.telegram.bot_token}/send#{METHOD_MAP[post[:type]]}",
-            **params(post, channel, opts)
+            **params(post, channel)
           )
 
-          handle_response(post, channel, res, opts)
+          handle_response(post, channel, res)
         end
 
         private
 
-        def params(post, channel, opts = {})
+        def params(post, channel)
           binary = post.dig(:misc)&.dig(:binary)
-          body = PrepareRequest.body(post, channel, opts)
+          body = PrepareRequest.body(post, channel)
 
           pars = {
             body: binary ? body : body.to_json,
@@ -42,29 +42,16 @@ module RedditToTelegram
           pars
         end
 
-        def handle_response(post, channel, res, opts = {})
-          push_error(post, channel, res, opts) unless res["ok"] || opts[:no_retry]
-          Gallery.push_remaining_gallery_data(post, channel, res, opts) if post[:type] == :gallery
-          Video.delete_file if post[:type] == :video && post.dig(:misc)&.dig(:binary)
+        def handle_response(post, channel, res)
+          log_error(post, channel, res) unless res["ok"]
+          Gallery.push_remaining_gallery_data(post, channel, res) if post[:type] == :gallery
+          Video.delete_file if post[:type] == :video && post.dig(:misc, :binary)
           res
         end
 
-        def push_error(post, channel, res, opts = {})
-          return if Configuration.telegram.error_channel_id.to_s.empty?
-
-          push(
-            {
-              type: :text,
-              id: post[:id],
-              text: "Channel: @#{channel}\n\nResponse: #{res}"
-            },
-            Configuration.telegram.error_channel_id,
-            opts.merge(
-              add_reddit_link: true,
-              disable_link_preview: true,
-              no_retry: true
-            )
-          )
+        def log_error(post, channel, res)
+          message = "\n\nChannel: #{channel}\n\nPost data: #{post}\n\nResponse: #{res}"
+          Errors.new(BadResponseFromTelegram, message)
         end
       end
     end

data/lib/reddit_to_telegram/telegram/prepare_request.rb

@@ -4,54 +4,64 @@ module RedditToTelegram
   module Telegram
     class PrepareRequest
       class << self
-        def body(post, chat_id, opts = {})
-          body = prepare_body(post, chat_id, opts)
-          body[:link_preview_options] = { is_disabled: true } if opts[:disable_link_preview]
-          body[:reply_parameters] = { message_id: opts[:reply_to] } if opts[:reply_to]
+        def body(post, chat_id)
+          body = prepare_body(post, chat_id)
+          body[:link_preview_options] = { is_disabled: true } if post.dig(:misc, :disable_link_preview)
+          body[:reply_parameters] = { message_id: post[:misc][:reply_to] } if post.dig(:misc, :reply_to)
           body
         end
 
         private
 
-        def prepare_body(post, chat_id, opts = {})
+        def prepare_body(post, chat_id)
           case post[:type]
           when :image
-            { chat_id: "@#{chat_id}", photo: post[:media], caption: prepare_text(post, chat_id, opts) }
+            { chat_id: "@#{chat_id}", photo: post[:media], caption: prepare_text(post, chat_id) }
           when :gallery
-            { chat_id: "@#{chat_id}", media: prepare_gallery_media(post), caption: prepare_text(post, chat_id, opts) }
+            { chat_id: "@#{chat_id}", media: prepare_gallery_media(post), caption: prepare_text(post, chat_id) }
           when :gif
-            { chat_id: "@#{chat_id}", animation: post[:media], caption: prepare_text(post, chat_id, opts) }
+            { chat_id: "@#{chat_id}", animation: post[:media], caption: prepare_text(post, chat_id) }
           when :text
-            { chat_id: "@#{chat_id}", text: prepare_text(post, chat_id, opts) }
+            { chat_id: "@#{chat_id}", text: prepare_text(post, chat_id) }
           when :video
             {
               chat_id: "@#{chat_id}",
               video: prepare_video(post),
               height: post[:misc][:video_height],
               width: post[:misc][:video_width],
-              caption: prepare_text(post, chat_id, opts)
+              caption: prepare_text(post, chat_id)
             }
           end
         end
 
-        def prepare_text(post, chat_id, opts = {})
+        def prepare_text(post, chat_id)
           text = post[:text]
 
-          text = Services::Translate.text(text, opts[:translate]) if opts[:translate]
+          text = translate(text)
+          text = add_reddit_link(text, post)
+          add_channel_handle(text, chat_id)
+        end
 
-          if opts[:add_reddit_link]
-            id = post[:id].split("_")[1]
-            text += "\n\nhttps://redd.it/#{id}"
-          end
+        def translate(text)
+          return text unless Configuration.translate
 
-          if opts[:add_channel_handle]
-            text += opts[:add_reddit_link] ? "\n" : "\n\n"
-            text += "@#{chat_id}"
-          end
+          Services::Translate.text(text, Configuration.translate)
+        end
 
+        def add_reddit_link(text, post)
+          return text unless Configuration.add_reddit_link
+
+          text += "\n\nhttps://redd.it/#{post[:id]}"
           text
         end
 
+        def add_channel_handle(text, chat_id)
+          return text unless Configuration.add_channel_handle
+
+          text += Configuration.add_reddit_link ? "\n" : "\n\n"
+          text + "@#{chat_id}"
+        end
+
         def prepare_gallery_media(post)
           Array(post[:media]).map { |link| { type: "photo", media: link } }
         end

data/lib/reddit_to_telegram/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RedditToTelegram
-  VERSION = "0.8.1"
+  VERSION = "0.10.0"
 end

data/reddit-to-telegram.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/dersnek/reddit-to-telegram"
   s.license     = "MIT"
 
-  s.add_dependency "aws-sdk-simpledb"
+  s.add_dependency "aws-sdk-dynamodb", "~> 1.106"
   s.add_dependency "httparty"
 
   s.add_development_dependency "rubocop"

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: reddit-to-telegram
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Mark Tityuk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-08 00:00:00.000000000 Z
+date: 2024-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: aws-sdk-simpledb
+  name: aws-sdk-dynamodb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.106'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.106'
 - !ruby/object:Gem::Dependency
   name: httparty
   requirement: !ruby/object:Gem::Requirement
@@ -75,7 +75,7 @@ files:
 - lib/reddit_to_telegram/reddit/output/imgur.rb
 - lib/reddit_to_telegram/services/translate.rb
 - lib/reddit_to_telegram/store.rb
-- lib/reddit_to_telegram/store/aws_simple_db.rb
+- lib/reddit_to_telegram/store/aws_dynamo_db.rb
 - lib/reddit_to_telegram/store/memory.rb
 - lib/reddit_to_telegram/store/temp_file.rb
 - lib/reddit_to_telegram/telegram/post.rb

data/lib/reddit_to_telegram/store/aws_simple_db.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require "aws-sdk-simpledb"
-require "json"
-
-module RedditToTelegram
-  module Store
-    class AWSSimpleDB
-      ITEM_NAME = "cached_data"
-
-      class << self
-        def client
-          @client ||= Aws::SimpleDB::Client.new(
-            access_key_id: Configuration.aws.access_key_id,
-            secret_access_key: Configuration.aws.secret_access_key,
-            region: Configuration.aws.region
-          )
-        end
-
-        private
-
-        attr_reader :reddit_token
-
-        def setup
-          check_credentials
-          create_domain unless client.list_domains.domain_names.include?(Configuration.aws.domain_name)
-          read_db
-        end
-
-        def check_credentials
-          return unless Configuration.store.type == :aws_simple_db
-
-          return if Configuration.aws.set_up?
-
-          Errors.new(
-            MissingConfiguration,
-            "Missing AWS credentials. Set them up or change store type to anything other than aws_simple_db"
-          )
-        end
-
-        def reddit_token=(val)
-          @reddit_token = val
-          write_db
-        end
-
-        def add_post(subreddit, id)
-          @posts[subreddit] = [] if @posts[subreddit].nil?
-          @posts[subreddit] << id
-          @posts[subreddit].shift if @posts[subreddit].count > Store::MAX_STORED_POSTS
-          write_db
-        end
-
-        def dup_post?(subreddit, id)
-          return false if @posts[subreddit].nil?
-
-          @posts[subreddit].include?(id)
-        end
-
-        def read_db
-          res = client.get_attributes(
-            {
-              domain_name: Configuration.aws.domain_name,
-              item_name: "cached_data",
-              consistent_read: true
-            }
-          )
-
-          return assign_default_values if res.attributes.empty?
-
-          assign_values_from_db(res)
-        end
-
-        def assign_values_from_db(data)
-          @reddit_token = data.attributes.find { |a| a.name == "reddit_token" }.value || ""
-          @posts = {}
-          data.attributes.each do |attr|
-            @posts[attr.name.split("_").last.to_sym] = JSON.parse(attr.value) if attr.name.match?(/posts_.+/)
-          end
-        end
-
-        def write_db
-          client.put_attributes(
-            {
-              domain_name: Configuration.aws.domain_name,
-              item_name: ITEM_NAME,
-              attributes: prepare_db_attrs
-            }
-          )
-        end
-
-        def prepare_db_attrs
-          attrs = [
-            {
-              name: "reddit_token",
-              value: @reddit_token,
-              replace: true
-            }
-          ]
-
-          @posts.each do |subreddit, values|
-            attrs << { name: "posts_#{subreddit}", value: values.to_json, replace: true }
-          end
-
-          attrs
-        end
-
-        def assign_default_values
-          @reddit_token = ""
-          @posts = {}
-        end
-
-        def create_domain
-          res = client.list_domains
-          return unless res.successful?
-
-          return if res.domain_names.include?(Configuration.aws.domain_name)
-
-          client.create_domain({ domain_name: Configuration.aws.domain_name })
-        end
-      end
-    end
-  end
-end