good_audible_story_sync 0.0.5

data/lib/good_audible_story_sync/audible/library_item.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+# encoding: utf-8
+# typed: true
+
+require "date"
+require "rainbow"
+
+module GoodAudibleStorySync
+  module Audible
+    class LibraryItem
+      extend T::Sig
+
+      sig { params(finished_at: T.nilable(DateTime)).void }
+      attr_writer :finished_at
+
+      sig { returns Hash }
+      attr_reader :data
+
+      sig { params(data: Hash).void }
+      def initialize(data)
+        @data = data
+      end
+
+      sig { returns T.nilable(DateTime) }
+      def finished_at
+        return @finished_at if defined?(@finished_at)
+        finished_at_str = @data["finished_at"]
+        if finished_at_str.nil? && @data.dig("listening_status", "is_finished")
+          finished_at_str = @data.dig("listening_status", "finished_at_timestamp")
+        end
+        @finished_at = finished_at_str ? DateTime.parse(finished_at_str) : nil
+      rescue Date::Error
+        nil
+      end
+
+      sig { returns T.nilable(DateTime) }
+      def last_listened_at
+        return @last_listened_at if defined?(@last_listened_at)
+        date_str = @data.dig("listening_status", "finished_at_timestamp")
+        @last_listened_at = date_str ? DateTime.parse(date_str) : nil
+      rescue Date::Error
+        nil
+      end
+
+      sig { returns T.nilable(DateTime) }
+      def added_to_library_at
+        return @added_to_library_at if defined?(@added_to_library_at)
+        date_added_str = @data.dig("library_status", "date_added")
+        @added_to_library_at = date_added_str ? DateTime.parse(date_added_str) : purchase_date
+      rescue Date::Error
+        nil
+      end
+
+      sig { returns T.nilable(String) }
+      def asin
+        @data["asin"]
+      end
+
+      sig { returns T::Array[String] }
+      def narrators
+        return @narrators if @narrators
+        narrator_str = T.let(@data["narrator"], T.nilable(String))
+        if narrator_str # data from database
+          @narrators = Util.split_words(narrator_str)
+        else # data from Audible API
+          hashes = @data["narrators"] || []
+          @narrators = hashes.map { |hash| hash["name"] }
+        end
+      end
+
+      sig { returns T::Array[String] }
+      def authors
+        return @authors if @authors
+        author_str = T.let(@data["author"], T.nilable(String))
+        if author_str # data from database
+          @authors = Util.split_words(author_str)
+        else # data from Audible API
+          hashes = @data["authors"] || []
+          @authors = hashes.map { |hash| hash["name"] }
+        end
+      end
+
+      sig { params(books_db: Database::AudibleBooks).returns(T::Boolean) }
+      def save_to_database(books_db)
+        isbn = self.isbn
+        return false unless isbn
+
+        books_db.upsert(isbn: isbn, title: title, author: Util.join_words(authors),
+          narrator: Util.join_words(narrators), finished_at: finished_at,
+          percent_complete: percent_complete)
+
+        true
+      end
+
+      sig { params(stylize: T::Boolean).returns(T.nilable(String)) }
+      def title(stylize: false)
+        value = @data["title"]
+        return value unless stylize && value
+        Rainbow(value).underline
+      end
+
+      sig { returns Integer }
+      def percent_complete
+        return @percent_complete if @percent_complete
+        pct = T.let(
+          @data["percent_complete"] || @data.dig("listening_status", "percent_complete"),
+          T.nilable(T.any(Float, Integer))
+        )
+        @percent_complete = pct.nil? ? 0 : pct.round
+      end
+
+      sig { returns T::Boolean }
+      def finished?
+        return true if finished_at || percent_complete == 100
+        is_finished = @data.dig("listening_status", "is_finished")
+        !!is_finished
+      end
+
+      sig { returns T::Boolean }
+      def started?
+        return @is_started if defined?(@is_started)
+        @is_started = percent_complete > 0 || !@data["listening_status"].nil?
+      end
+
+      sig { returns T.nilable(String) }
+      def isbn
+        @data["isbn"]
+      end
+
+      sig { returns T.nilable(Integer) }
+      def time_remaining_in_seconds
+        @data.dig("listening_status", "time_remaining_seconds")
+      end
+
+      sig { params(indent_level: Integer, stylize: T::Boolean).returns(String) }
+      def title_and_authors(indent_level: 0, stylize: false)
+        "#{Util::TAB * indent_level}#{title(stylize: stylize)} by #{Util.join_words(authors)}"
+      end
+
+      sig { params(indent_level: Integer, stylize: T::Boolean).returns(String) }
+      def narrator_summary(indent_level: 0, stylize: false)
+        value = "Narrated by #{Util.join_words(narrators)}"
+        value = Rainbow(value).italic if stylize
+        "#{Util::TAB * indent_level}#{Util::NEWLINE_EMOJI} #{value}"
+      end
+
+      sig { params(stylize: T::Boolean).returns(String) }
+      def finish_status(stylize: false)
+        finished_at = self.finished_at
+        if finished_at
+          value = "Finished #{Util.pretty_time(finished_at)}"
+          value = Rainbow(value).green if stylize
+          value
+        elsif finished?
+          value = "Finished"
+          value = Rainbow(value).green if stylize
+          value
+        elsif started?
+          value = "#{percent_complete}% complete"
+          value = Rainbow(value).yellow if stylize
+          value
+        else
+          value = "Not started"
+          value = Rainbow(value).white if stylize
+          value
+        end
+      end
+
+      sig { returns String }
+      def inspect
+        @data.inspect
+      end
+
+      sig { params(indent_level: Integer, stylize: T::Boolean).returns(String) }
+      def to_s(indent_level: 0, stylize: false)
+        line1 = "#{title_and_authors(indent_level: indent_level, stylize: stylize)} — " \
+          "#{finish_status(stylize: stylize)}"
+        line2 = narrator_summary(indent_level: indent_level + 1, stylize: stylize)
+        [line1, line2].join("\n")
+      end
+
+      sig { returns T.nilable(String) }
+      def search_query
+        return unless title
+        [title, Util.join_words(authors)].compact.join(" ")
+      end
+
+      sig { returns T.nilable(DateTime) }
+      def purchase_date
+        return @purchase_date if defined?(@purchase_date)
+        purchase_date_str = @data["purchase_date"]
+        @purchase_date = purchase_date_str ? DateTime.parse(purchase_date_str) : nil
+      rescue Date::Error
+        nil
+      end
+
+      # Public: Get a rough idea of when the item would have been listened to. The start date will be too broad, as
+      # it's just when the item was added to the library and not necessarily when it was begun.
+      sig { returns T::Range[T.nilable(DateTime)] }
+      def listening_time_range
+        @listening_time_range ||= Range.new(added_to_library_at, last_listened_at)
+      end
+
+      sig { returns T::Hash[Symbol, T.untyped] }
+      def to_h
+        @to_h ||= @data.reject { |k, v| v.nil? }.map { |k, v| [k.to_sym, v] }.to_h.merge(
+          finished_at: finished_at&.iso8601,
+          purchase_date: purchase_date&.iso8601,
+        )
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/audible/user_profile.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+# typed: true
+
+module GoodAudibleStorySync
+  module Audible
+    class UserProfile
+      extend T::Sig
+
+      sig { params(data: Hash).void }
+      def initialize(data)
+        @data = data
+      end
+
+      sig { returns T.nilable(String) }
+      def user_id
+        @data["user_id"]
+      end
+
+      sig { returns T.nilable(String) }
+      def name
+        @data["name"]
+      end
+
+      sig { returns T.nilable(String) }
+      def email
+        @data["email"]
+      end
+
+      sig { params(indent_level: Integer).returns(String) }
+      def to_s(indent_level: 0)
+        tab = Util::TAB * indent_level
+        line1 = "#{tab}Audible user ID: #{user_id}"
+        line2 = "#{tab}Name: #{name}"
+        line3 = "#{tab}Email: #{email}"
+        [line1, line2, line3].join("\n")
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/audible.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module GoodAudibleStorySync
+  module Audible
+  end
+end
+
+require_relative "audible/auth"
+require_relative "audible/auth_flow"
+require_relative "audible/client"
+require_relative "audible/library"
+require_relative "audible/library_item"
+require_relative "audible/user_profile"

data/lib/good_audible_story_sync/database/audible_books.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# typed: true
+
+module GoodAudibleStorySync
+  module Database
+    class AudibleBooks
+      extend T::Sig
+
+      TABLE_NAME = "audible_books"
+
+      sig { params(db: SQLite3::Database).void }
+      def initialize(db:)
+        @db = db
+      end
+
+      sig { void }
+      def create_table
+        puts "#{Util::INFO_EMOJI} Ensuring table #{TABLE_NAME} exists..."
+        @db.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS #{TABLE_NAME} (
+            isbn TEXT PRIMARY KEY,
+            title TEXT,
+            author TEXT,
+            narrator TEXT,
+            finished_at TEXT
+          );
+        SQL
+        unless Client.column_exists?(db: @db, table_name: TABLE_NAME, column_name: "percent_complete")
+          puts "#{Util::INFO_EMOJI} Adding percent_complete column to #{TABLE_NAME}..."
+          @db.execute("ALTER TABLE #{TABLE_NAME} ADD COLUMN percent_complete INTEGER")
+        end
+      end
+
+      sig { returns T::Array[T::Hash[String, T.untyped]] }
+      def find_all
+        @db.execute("SELECT isbn, title, author, narrator, finished_at, percent_complete " \
+          "FROM #{TABLE_NAME} ORDER BY finished_at DESC, percent_complete DESC, title ASC, isbn ASC")
+      end
+
+      sig do
+        params(
+          isbn: String,
+          title: T.nilable(String),
+          author: T.nilable(String),
+          narrator: T.nilable(String),
+          finished_at: T.nilable(T.any(String, DateTime, Time, Date)),
+          percent_complete: Integer
+        ).void
+      end
+      def upsert(isbn:, title:, author:, narrator:, finished_at:, percent_complete:)
+        puts "#{Util::INFO_EMOJI} Saving Audible book #{isbn}..."
+        finished_at_str = if finished_at.respond_to?(:iso8601)
+          T.unsafe(finished_at).iso8601
+        else
+          finished_at
+        end
+        values = [isbn, title, author, narrator, finished_at_str, percent_complete]
+        @db.execute(
+          "INSERT INTO #{TABLE_NAME} (isbn, title, author, narrator, finished_at, percent_complete) " \
+          "VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(isbn) DO UPDATE SET title=excluded.title, " \
+          "author=excluded.author, narrator=excluded.narrator, " \
+          "finished_at=excluded.finished_at, percent_complete=excluded.percent_complete", values)
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/database/client.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+# typed: true
+
+module GoodAudibleStorySync
+  module Database
+    class Client
+      extend T::Sig
+
+      DEFAULT_DATABASE_FILE = "good_audible_story_sync.db"
+
+      sig { params(db_file: String, cipher: T.nilable(Util::Cipher)).returns(Client) }
+      def self.load(db_file = DEFAULT_DATABASE_FILE, cipher: nil)
+        client = new(db_file: db_file, cipher: cipher)
+        client.create_tables
+        client
+      end
+
+      sig do
+        params(db: SQLite3::Database, table_name: String, column_name: String).returns(T::Boolean)
+      end
+      def self.column_exists?(db:, table_name:, column_name:)
+        result = db.get_first_value("SELECT COUNT(*) FROM pragma_table_info(?) WHERE name = ?",
+          table_name, column_name)
+        result == 1
+      end
+
+      sig { returns SQLite3::Database }
+      attr_reader :db
+
+      sig { returns Util::Cipher }
+      attr_reader :cipher
+
+      sig { returns Credentials }
+      attr_reader :credentials
+
+      sig { returns AudibleBooks }
+      attr_reader :audible_books
+
+      sig { returns GoodreadsBooks }
+      attr_reader :goodreads_books
+
+      sig { returns StorygraphBooks }
+      attr_reader :storygraph_books
+
+      sig { returns SyncTimes }
+      attr_reader :sync_times
+
+      sig { params(db_file: String, cipher: T.nilable(Util::Cipher)).void }
+      def initialize(db_file: DEFAULT_DATABASE_FILE, cipher: nil)
+        @db = SQLite3::Database.new(db_file)
+        @db.results_as_hash = true
+        @cipher = cipher || Util::Cipher.new
+        @credentials = Credentials.new(db_client: self)
+        @audible_books = AudibleBooks.new(db: @db)
+        @goodreads_books = GoodreadsBooks.new(db: @db)
+        @storygraph_books = StorygraphBooks.new(db: @db)
+        @sync_times = SyncTimes.new(db: @db)
+      end
+
+      sig { void }
+      def create_tables
+        @audible_books.create_table
+        @storygraph_books.create_table
+        @goodreads_books.create_table
+        @credentials.create_table
+        @sync_times.create_table
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/database/credentials.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+# typed: true
+
+module GoodAudibleStorySync
+  module Database
+    class Credentials
+      extend T::Sig
+
+      TABLE_NAME = "credentials"
+
+      sig { params(db_client: Database::Client).void }
+      def initialize(db_client:)
+        @db = T.let(db_client.db, SQLite3::Database)
+        @cipher = T.let(db_client.cipher, Util::Cipher)
+      end
+
+      sig { params(key: String).returns(T.nilable(T::Hash[String, T.untyped])) }
+      def find(key:)
+        puts "#{Util::INFO_EMOJI} Looking for '#{key}' credentials..."
+        encrypted_value = @db.get_first_value("SELECT value FROM #{TABLE_NAME} WHERE key = ?", key)
+        return unless encrypted_value
+
+        value = @cipher.decrypt(encrypted_value)
+        JSON.parse(value)
+      end
+
+      sig { void }
+      def create_table
+        puts "#{Util::INFO_EMOJI} Ensuring table #{TABLE_NAME} exists..."
+        @db.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS #{TABLE_NAME} (
+            key TEXT PRIMARY KEY,
+            value BLOB NOT NULL
+          );
+        SQL
+      end
+
+      sig { params(key: String, value: T::Hash[String, T.untyped]).void }
+      def upsert(key:, value:)
+        encrypted_value = @cipher.encrypt(value.to_json)
+        values = [key, encrypted_value]
+        puts "#{Util::INFO_EMOJI} Saving '#{key}' credentials..."
+        @db.execute("INSERT INTO #{TABLE_NAME} (key, value) VALUES (?, ?) " \
+          "ON CONFLICT(key) DO UPDATE SET value=excluded.value", values)
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/database/goodreads_books.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# typed: true
+
+module GoodAudibleStorySync
+  module Database
+    class GoodreadsBooks
+      extend T::Sig
+
+      TABLE_NAME = "goodreads_books"
+
+      sig { params(db: SQLite3::Database).void }
+      def initialize(db:)
+        @db = db
+      end
+
+      sig { void }
+      def create_table
+        puts "#{Util::INFO_EMOJI} Ensuring table #{TABLE_NAME} exists..."
+        @db.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS #{TABLE_NAME} (
+            slug TEXT PRIMARY KEY,
+            title TEXT,
+            author TEXT,
+            status TEXT,
+            isbn TEXT
+          );
+        SQL
+      end
+
+      sig { returns T::Array[T::Hash[String, T.untyped]] }
+      def find_all
+        @db.execute("SELECT slug, title, author, status, isbn " \
+          "FROM #{TABLE_NAME} ORDER BY title ASC, slug ASC")
+      end
+
+      sig { params(slug: String).void }
+      def delete(slug)
+        puts "#{Util::INFO_EMOJI} Removing cached Goodreads book #{slug}..."
+        @db.execute("DELETE FROM #{TABLE_NAME} WHERE slug = ?", slug)
+      end
+
+      sig do
+        params(
+          slug: String,
+          title: T.nilable(String),
+          author: T.nilable(String),
+          isbn: T.nilable(String),
+          status: T.nilable(String)
+        ).void
+      end
+      def upsert(slug:, title:, author:, isbn:, status:)
+        puts "#{Util::INFO_EMOJI} Saving Goodreads book #{slug}..."
+        values = [slug, title, author, isbn, status]
+        @db.execute("INSERT INTO #{TABLE_NAME} (slug, title, author, isbn, status) " \
+          "VALUES (?, ?, ?, ?, ?) ON CONFLICT(slug) DO UPDATE SET title=excluded.title, " \
+          "author=excluded.author, isbn=excluded.isbn, status=excluded.status", values)
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/database/storygraph_books.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+# typed: true
+
+module GoodAudibleStorySync
+  module Database
+    class StorygraphBooks
+      extend T::Sig
+
+      TABLE_NAME = "storygraph_books"
+
+      sig { params(db: SQLite3::Database).void }
+      def initialize(db:)
+        @db = db
+      end
+
+      sig { void }
+      def create_table
+        puts "#{Util::INFO_EMOJI} Ensuring table #{TABLE_NAME} exists..."
+        @db.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS #{TABLE_NAME} (
+            id TEXT PRIMARY KEY,
+            title TEXT,
+            author TEXT,
+            finished_on TEXT
+          );
+        SQL
+        unless Client.column_exists?(db: @db, table_name: TABLE_NAME, column_name: "isbn")
+          puts "#{Util::INFO_EMOJI} Adding isbn column to #{TABLE_NAME}..."
+          @db.execute("ALTER TABLE #{TABLE_NAME} ADD COLUMN isbn TEXT")
+        end
+        unless Client.column_exists?(db: @db, table_name: TABLE_NAME, column_name: "status")
+          puts "#{Util::INFO_EMOJI} Adding status column to #{TABLE_NAME}..."
+          @db.execute("ALTER TABLE #{TABLE_NAME} ADD COLUMN status TEXT")
+        end
+      end
+
+      sig { returns T::Array[T::Hash[String, T.untyped]] }
+      def find_all
+        @db.execute("SELECT id, title, author, finished_on, status " \
+          "FROM #{TABLE_NAME} ORDER BY finished_on DESC, title ASC, id ASC")
+      end
+
+      sig { params(id: String).void }
+      def delete(id)
+        puts "#{Util::INFO_EMOJI} Removing cached Storygraph book #{id}..."
+        @db.execute("DELETE FROM #{TABLE_NAME} WHERE id = ?", id)
+      end
+
+      sig do
+        params(
+          id: String,
+          title: T.nilable(String),
+          author: T.nilable(String),
+          finished_on: T.nilable(T.any(String, Date)),
+          isbn: T.nilable(String),
+          status: T.nilable(String)
+        ).void
+      end
+      def upsert(id:, title:, author:, finished_on:, isbn:, status:)
+        puts "#{Util::INFO_EMOJI} Saving Storygraph book #{id}..."
+        finished_on_str = if finished_on.respond_to?(:iso8601)
+          T.unsafe(finished_on).iso8601
+        else
+          finished_on
+        end
+        values = [id, title, author, finished_on_str, isbn, status]
+        @db.execute("INSERT INTO #{TABLE_NAME} (id, title, author, finished_on, isbn, status) " \
+          "VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET title=excluded.title, " \
+          "author=excluded.author, finished_on=excluded.finished_on, isbn=excluded.isbn, " \
+          "status=excluded.status", values)
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/database/sync_times.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# typed: true
+
+require "date"
+
+module GoodAudibleStorySync
+  module Database
+    class SyncTimes
+      extend T::Sig
+
+      TABLE_NAME = "sync_times"
+
+      sig { params(db: SQLite3::Database).void }
+      def initialize(db:)
+        @db = db
+      end
+
+      sig { params(key: String).returns(T.nilable(DateTime)) }
+      def find(key)
+        puts "#{Util::INFO_EMOJI} Checking when #{key} was last synced..."
+        timestamp_str = @db.get_first_value("SELECT timestamp FROM #{TABLE_NAME} WHERE key = ?", key)
+        return unless timestamp_str
+
+        DateTime.parse(timestamp_str)
+      end
+
+      sig { void }
+      def create_table
+        puts "#{Util::INFO_EMOJI} Ensuring table #{TABLE_NAME} exists..."
+        @db.execute <<~SQL
+          CREATE TABLE IF NOT EXISTS #{TABLE_NAME} (
+            key TEXT PRIMARY KEY,
+            timestamp TEXT
+          );
+        SQL
+      end
+
+      sig { params(key: String).void }
+      def touch(key)
+        upsert(key: key, timestamp: DateTime.now)
+      end
+
+      sig { params(key: String, timestamp: T.nilable(DateTime)).void }
+      def upsert(key:, timestamp:)
+        puts "#{Util::INFO_EMOJI} Saving sync time #{key}..."
+        values = [key, timestamp&.iso8601]
+        @db.execute("INSERT INTO #{TABLE_NAME} (key, timestamp) " \
+          "VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET timestamp=excluded.timestamp", values)
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/database.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# typed: true
+
+require "sqlite3"
+
+module GoodAudibleStorySync
+  module Database
+  end
+end
+
+require_relative "database/audible_books"
+require_relative "database/client"
+require_relative "database/credentials"
+require_relative "database/goodreads_books"
+require_relative "database/storygraph_books"
+require_relative "database/sync_times"