reddit-to-telegram 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '05893e8e006a0f401dbcec8e91cfd46be3cf3b53bbc1c9e89ccd95620db3087c'
-  data.tar.gz: 62ef80526ab1051177eafcab26de219b6d196262024c473dc53813fcbac32365
+  metadata.gz: 00436ff5f5d09c81d76f4d49f3cc3996e983857f1fbff2ad2db006ea014c0e96
+  data.tar.gz: ca6e585387a1165a9dacdee453d4853e531b727f9498918c97675d9484275b6c
 SHA512:
-  metadata.gz: 4319bf2ff9cbe27433514492093865c55ee65a77ef6d1eaae1a89376ea37cf0b16a998856b8f5c7ad21f7442d4ca2aca9f710d74fd40a7def9d8859f429d0dee
-  data.tar.gz: 58a917a293a78fdca894d5249114d26f19c79d27574ea02d3f412152aec321a45fb7ebc6672e63e46ebafcad5c3ed561867ace3420b15a1dd5b77d33d26ad392
+  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

@@ -20,7 +20,7 @@ Or `gem install reddit-to-telegram`. Don't forget to `require` it.
 
 ## Prerequisites
 - [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 SimpleDB (best available storage type, also default one). I also recommend hosting the bot on AWS lambda, since it would be free.
+- (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
 
 It is pretty congifurable, either dynamically or via ENV variables.
@@ -35,16 +35,15 @@ logger                    | -                             | Which logger to use.
 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 SimpleDB storage                                                                                                                      |
-aws.domain_name           | RTT_AWS_DOMAIN_NAME           | Domain name to use for SimpleDB                                                                                                                                              |
-aws.region                | RTT_AWS_REGION                | AWS region your SimpleDB will be hosted on. Beware, it's not available in all regions.                                                                                       |
-aws.secret_access_key     | RTT_AWS_SECRET_ACCESS_KEY     | Your AWS access key ID. Needed for AWS SimpleDB storage.                                                                                                                     |
+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_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 |
+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)                                                              |
 

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

@@ -37,7 +37,7 @@ module RedditToTelegram
 
     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
@@ -57,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)
@@ -75,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

@@ -4,7 +4,9 @@ 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
 

data/lib/reddit_to_telegram/post.rb

@@ -7,9 +7,11 @@ module RedditToTelegram
         check_config
         Store.setup
 
-        sources.each do |telegram_chat_id, subreddit|
-          res = Reddit::Fetch.hot(subreddit)
-          handle_res(res, subreddit, telegram_chat_id)
+        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
 
@@ -36,16 +38,14 @@ module RedditToTelegram
       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)
-        Store::Posts.add(subreddit, post[:id])
-        res
+        Telegram::Post.push(post, telegram_chat_id)
       end
 
       def res_ok?(res)
@@ -60,10 +60,6 @@ module RedditToTelegram
         end
       end
 
-      def find_new_post(subreddit, posts)
-        posts.find { |post| !Store::Posts.dup?(subreddit, post[:id]) }
-      end
-
       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")

data/lib/reddit_to_telegram/reddit/output.rb

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

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/prepare_request.rb

@@ -51,8 +51,7 @@ module RedditToTelegram
         def add_reddit_link(text, post)
           return text unless Configuration.add_reddit_link
 
-          id = post[:id]&.split("_")&.dig(1)
-          text += "\n\nhttps://redd.it/#{id}" if id
+          text += "\n\nhttps://redd.it/#{post[:id]}"
           text
         end
 

data/lib/reddit_to_telegram/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RedditToTelegram
-  VERSION = "0.9.0"
+  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.9.0
+  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