good_audible_story_sync 0.0.5

data/lib/good_audible_story_sync/audible/client.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+# typed: true
+# encoding: utf-8
+
+require "date"
+require "httparty"
+
+module GoodAudibleStorySync
+  module Audible
+    class Client
+      extend T::Sig
+
+      class NotAuthenticatedError < StandardError; end
+
+      US_DOMAIN = "com"
+
+      sig { params(auth: Auth, options: Options, credentials_db: Database::Credentials).void }
+      def initialize(auth:, options:, credentials_db:)
+        @auth = auth
+        @api_url = "https://api.audible.#{US_DOMAIN}"
+        @have_attempted_token_refresh = T.let(false, T::Boolean)
+        @credentials_db = credentials_db
+        @options = options
+      end
+
+      sig { returns(UserProfile) }
+      def get_user_profile
+        raise NotAuthenticatedError unless @auth.access_token
+
+        url = "#{@api_url}/user/profile"
+        puts "#{Util::INFO_EMOJI} GET #{url}"
+        make_request = -> { HTTParty.get(url, headers: headers) }
+        data = make_json_request(make_request, action: "get user profile")
+        UserProfile.new(data)
+      end
+
+      # https://audible.readthedocs.io/en/master/misc/external_api.html#get--1.0-stats-status-finished
+      sig { returns T::Hash[String, DateTime] }
+      def get_finish_times_by_asin
+        raise NotAuthenticatedError unless @auth.access_token
+
+        url = "#{@api_url}/1.0/stats/status/finished"
+        puts "#{Util::INFO_EMOJI} GET #{url}"
+        make_request = -> { HTTParty.get(url, headers: headers) }
+        data = make_json_request(make_request, action: "get finish times by ASIN")
+        finished_items = (data["mark_as_finished_status_list"] || [])
+          .select { |item| item["is_marked_as_finished"] }
+        result = T.let({}, T::Hash[String, DateTime])
+        finished_items.each do |item|
+          asin = item["asin"]
+          timestamp = DateTime.parse(item["event_timestamp"])
+          if !result.key?(asin) || timestamp > result[asin]
+            result[asin] = timestamp
+          end
+        end
+        result
+      end
+
+      # https://audible.readthedocs.io/en/master/misc/external_api.html#get--1.0-stats-aggregates
+      sig { returns Hash }
+      def get_aggregate_stats
+        raise NotAuthenticatedError unless @auth.access_token
+
+        params = {
+          "locale" => "en_US",
+          "response_groups" => "total_listening_stats",
+          "store" => "Audible",
+        }
+        url = "#{@api_url}/1.0/stats/aggregates?#{URI.encode_www_form(params)}"
+        puts "#{Util::INFO_EMOJI} GET #{url}"
+        make_request = -> { HTTParty.get(url, headers: headers) }
+        make_json_request(make_request, action: "get aggregate stats")
+      end
+
+      # https://audible.readthedocs.io/en/master/misc/external_api.html#get--1.0-collections
+      sig { returns Hash }
+      def get_collections
+        raise NotAuthenticatedError unless @auth.access_token
+
+        url = "#{@api_url}/1.0/collections"
+        puts "#{Util::INFO_EMOJI} GET #{url}"
+        make_request = -> { HTTParty.get(url, headers: headers) }
+        make_json_request(make_request, action: "get collections")
+      end
+
+      # https://audible.readthedocs.io/en/master/misc/external_api.html#get--1.0-library-(string-asin)
+      sig { params(asin: String).returns(LibraryItem) }
+      def get_library_item(asin:)
+        raise NotAuthenticatedError unless @auth.access_token
+
+        params = {
+          "response_groups" => "contributors,media,price,product_attrs,product_desc," \
+            "product_details,product_extended_attrs,product_plan_details,product_plans," \
+            "rating,sample,sku,series,reviews,ws4v,origin,relationships,review_attrs," \
+            "categories,badge_types,category_ladders,claim_code_url,is_downloaded," \
+            "is_finished,is_returnable,origin_asin,pdf_url,percent_complete,periodicals," \
+            "provided_review",
+        }
+        url = "#{@api_url}/1.0/library/#{asin}?#{URI.encode_www_form(params)}"
+        puts "#{Util::INFO_EMOJI} GET #{url}"
+        make_request = -> { HTTParty.get(url, headers: headers) }
+        data = make_json_request(make_request, action: "get library item #{asin}")
+        LibraryItem.new(data["item"])
+      end
+
+      # https://audible.readthedocs.io/en/latest/misc/external_api.html#get--1.0-orders
+      def get_orders
+        raise NotAuthenticatedError unless @auth.access_token
+
+        url = "#{@api_url}/1.0/orders"
+        puts "#{Util::INFO_EMOJI} GET #{url}"
+        make_request = -> { HTTParty.get(url, headers: headers) }
+        make_json_request(make_request, action: "get orders")
+      end
+
+      # https://audible.readthedocs.io/en/master/misc/external_api.html#library
+      sig { params(page: Integer, per_page: Integer).returns([Integer, T::Array[LibraryItem]]) }
+      def get_library_page(page: 1, per_page: 50)
+        raise NotAuthenticatedError unless @auth.access_token
+
+        params = {
+          "sort_by" => "-PurchaseDate",
+          "include_pending" => "false",
+          "num_results" => per_page,
+          "page" => page,
+          "response_groups" => "contributors,is_finished,listening_status,percent_complete,product_attrs,product_desc,product_details",
+        }
+        url = "#{@api_url}/1.0/library?#{URI.encode_www_form(params)}"
+        puts "#{Util::INFO_EMOJI} GET #{url}"
+        make_request = -> { HTTParty.get(url, headers: headers) }
+        total_count = T.let(0, Integer)
+        process_headers = ->(headers) { total_count = headers["total-count"].to_i }
+        library_data = make_json_request(make_request, action: "get library",
+          process_headers: process_headers)
+        page_items = library_data["items"].map { |data| LibraryItem.new(data) }
+        [total_count, page_items]
+      end
+
+      # https://audible.readthedocs.io/en/latest/misc/external_api.html#get--1.0-badges-progress
+      def get_badge_progress
+        raise NotAuthenticatedError unless @auth.access_token
+
+        params = { locale: "en_US", store: "Audible" }
+        url = "#{@api_url}/1.0/badges/progress?#{URI.encode_www_form(params)}"
+        puts "#{Util::INFO_EMOJI} GET #{url}"
+        make_request = -> { HTTParty.get(url, headers: headers) }
+        make_json_request(make_request, action: "get badge progress")
+      end
+
+      sig { returns Library }
+      def get_all_library_pages
+        per_page = 999
+        all_items = T.let([], T::Array[LibraryItem])
+        total_count, page_items = get_library_page(page: 1, per_page: per_page)
+        puts "#{Util::TAB}Loaded #{page_items.size} of #{total_count} item(s) in library"
+        all_items.concat(page_items)
+        total_pages = (total_count.to_f / per_page).ceil
+        (2..total_pages).each do |page|
+          _, page_items = get_library_page(page: page, per_page: per_page)
+          puts "#{Util::TAB}Loaded #{all_items.size + page_items.size} of #{total_count} " \
+            "item(s) in library"
+          all_items.concat(page_items)
+        end
+        Library.new(items: all_items)
+      end
+
+      private
+
+      sig do
+        params(
+          make_request: T.proc.returns(HTTParty::Response),
+          action: String,
+          process_headers: T.nilable(T.proc.params(arg0: Hash).void),
+        ).returns(T.untyped)
+      end
+      def make_json_request(make_request, action:, process_headers: nil)
+        response = make_request.call
+        process_headers&.call(response.headers)
+        handle_json_response(action: action, response: response)
+      rescue Auth::InvalidTokenError, Auth::ForbiddenError
+        if @have_attempted_token_refresh
+          puts "#{Util::ERROR_EMOJI} Invalid token persists after refreshing it, giving up"
+          nil
+        else
+          refresh_token
+          response = make_request.call
+          process_headers&.call(response.headers)
+          handle_json_response(action: action, response: response)
+        end
+      end
+
+      sig { params(action: String, response: HTTParty::Response).returns(T.untyped) }
+      def handle_json_response(action:, response:)
+        Auth.handle_http_error(action: action, response: response) unless response.code == 200
+        JSON.parse(response.body)
+      end
+
+      sig { returns(T::Hash[String, String]) }
+      def headers
+        { "Authorization" => "Bearer #{@auth.access_token}" }
+      end
+
+      sig { void }
+      def refresh_token
+        puts "#{Util::INFO_EMOJI} Refreshing Audible access token..."
+        new_access_token, new_expires = Auth.refresh_token(@auth.refresh_token)
+
+        if new_access_token.size > 0
+          @auth.access_token = new_access_token
+          @auth.expires = new_expires
+          @auth.save_to_database(@credentials_db)
+          @have_attempted_token_refresh = true
+        else
+          puts "#{Util::ERROR_EMOJI} Failed to refresh Audible access token, giving up"
+          raise NotAuthenticatedError
+        end
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/audible/library.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+# typed: true
+# encoding: utf-8
+
+require "date"
+
+module GoodAudibleStorySync
+  module Audible
+    class Library
+      extend T::Sig
+
+      SYNC_TIME_KEY = "audible_library"
+
+      sig do
+        params(client: Client, options: Options, db_client: Database::Client).returns(Library)
+      end
+      def self.load_with_finish_times(client:, options:, db_client:)
+        load_finish_times = T.let(false, T::Boolean)
+        library_cache_last_modified = db_client.sync_times.find(SYNC_TIME_KEY)&.to_time
+        library_is_cached = !library_cache_last_modified.nil?
+        if library_is_cached
+          puts "#{Util::INFO_EMOJI} Audible library last cached at #{Util.pretty_time(library_cache_last_modified)}"
+        end
+        should_refresh_library = library_cache_last_modified &&
+          library_cache_last_modified > options.refresh_cutoff_time
+
+        if library_is_cached && should_refresh_library
+          library = load_from_database(db_client.audible_books)
+          load_finish_times = !library.any_finished_time_loaded?
+        else
+          puts "#{Util::INFO_EMOJI} Updating Audible library cache..." if library_is_cached
+          library = client.get_all_library_pages
+          load_finish_times = true
+        end
+
+        if load_finish_times
+          finish_times_by_asin = client.get_finish_times_by_asin
+          library.populate_finish_times(finish_times_by_asin)
+          library.save_to_database(db_client)
+        end
+
+        library
+      end
+
+      sig { params(books_db: Database::AudibleBooks).returns(Library) }
+      def self.load_from_database(books_db)
+        library = new
+        library.load_from_database(books_db)
+        library
+      end
+
+      sig { returns T::Array[LibraryItem] }
+      attr_reader :items
+
+      sig { params(items: T::Array[LibraryItem]).void }
+      def initialize(items: [])
+        @items = items
+        @loaded_from_database = T.let(false, T::Boolean)
+      end
+
+      sig { params(isbn: String).returns(T.nilable(LibraryItem)) }
+      def find_by_isbn(isbn)
+        items.detect { |library_item| library_item.isbn == isbn }
+      end
+
+      sig { returns T::Hash[String, Date] }
+      def finish_dates_by_isbn
+        finished_items.each_with_object({}) do |library_item, result|
+          isbn = library_item.isbn
+          finish_time = library_item.finished_at
+          if isbn && !isbn.empty? && finish_time
+            result[isbn] = finish_time.to_date
+          end
+        end
+      end
+
+      sig { returns Integer }
+      def total_items
+        items.size
+      end
+
+      sig { params(db_client: Database::Client).returns(Integer) }
+      def save_to_database(db_client)
+        puts "#{Util::SAVE_EMOJI} Caching Audible library in database..."
+        total_saved = 0
+        books_db = db_client.audible_books
+        items.each do |library_item|
+          isbn = library_item.isbn
+          if isbn
+            success = library_item.save_to_database(books_db)
+            total_saved += 1 if success
+          else
+            puts "#{Util::TAB}#{Util::WARNING_EMOJI} Skipping book with no ISBN: #{library_item}"
+          end
+        end
+        db_client.sync_times.touch(SYNC_TIME_KEY)
+        total_saved
+      end
+
+      sig { returns T::Boolean }
+      def loaded_from_database?
+        @loaded_from_database
+      end
+
+      sig { params(books_db: Database::AudibleBooks).returns(T::Boolean) }
+      def load_from_database(books_db)
+        puts "#{Util::INFO_EMOJI} Loading cached Audible library..."
+
+        rows = books_db.find_all
+        @items = rows.map { |row| LibraryItem.new(row) }
+
+        @loaded_from_database = true
+      end
+
+      sig { returns T::Boolean }
+      def any_finished_time_loaded?
+        items.any? { |library_item| !library_item.finished_at.nil? }
+      end
+
+      sig { params(finish_times_by_asin: T::Hash[String, DateTime]).void }
+      def populate_finish_times(finish_times_by_asin)
+        items.each do |library_item|
+          asin = library_item.asin
+          library_item.finished_at = if asin
+            finish_times_by_asin[asin]
+          end
+        end
+
+        @finished_items = @unfinished_items = nil # force recalculation
+
+        if total_finished < 1
+          puts "#{Util::INFO_EMOJI} No books in Audible library have been finished."
+        else
+          puts "#{Util::INFO_EMOJI} Loaded finished status for #{total_finished} " \
+            "#{finished_item_units} from Audible library."
+        end
+      end
+
+      sig { returns T::Array[LibraryItem] }
+      def finished_items
+        calculate_finished_unfinished_items
+        @finished_items
+      end
+
+      sig { returns T::Array[LibraryItem] }
+      def started_items
+        calculate_started_not_started_items
+        @started_items
+      end
+
+      sig { returns T::Array[LibraryItem] }
+      def not_started_items
+        calculate_started_not_started_items
+        @not_started_items
+      end
+
+      sig { returns T::Array[LibraryItem] }
+      def unfinished_items
+        calculate_finished_unfinished_items
+        @unfinished_items
+      end
+
+      sig { returns Integer }
+      def total_finished
+        @total_finished ||= finished_items.size
+      end
+
+      sig { returns Integer }
+      def finished_percent
+        @finished_percent ||= (total_finished.to_f / total_items * 100).round
+      end
+
+      sig { returns Integer }
+      def total_started
+        @total_started ||= started_items.size
+      end
+
+      sig { returns Integer }
+      def started_percent
+        @started_percent ||= (total_started.to_f / total_items * 100).round
+      end
+
+      sig { returns Integer }
+      def total_unfinished
+        @total_unfinished ||= unfinished_items.size
+      end
+
+      sig { returns Integer }
+      def unfinished_percent
+        @unfinished_percent ||= (total_unfinished.to_f / total_items * 100).round
+      end
+
+      sig { returns Integer }
+      def total_not_started
+        @total_not_started ||= not_started_items.size
+      end
+
+      sig { returns Integer }
+      def not_started_percent
+        @not_started_percent ||= (total_not_started.to_f / total_items * 100).round
+      end
+
+      sig { returns String }
+      def finished_item_units
+        total_finished == 1 ? "book" : "books"
+      end
+
+      sig { returns String }
+      def item_units
+        total_items == 1 ? "book" : "books"
+      end
+
+      sig { returns String }
+      def started_item_units
+        total_started == 1 ? "book" : "books"
+      end
+
+      sig { returns String }
+      def unfinished_item_units
+        total_unfinished == 1 ? "book" : "books"
+      end
+
+      sig { returns String }
+      def not_started_item_units
+        total_not_started == 1 ? "book" : "books"
+      end
+
+      sig { returns String }
+      def to_json
+        JSON.pretty_generate(items.map(&:to_h))
+      end
+
+      sig { params(limit: Integer, stylize: T::Boolean).returns(String) }
+      def finished_items_summary(limit: 5, stylize: false)
+        lines = T.let([
+          "#{Util::DONE_EMOJI} #{total_finished} #{finished_item_units} " \
+            "(#{finished_percent}%) in Audible library have been finished:",
+        ], T::Array[String])
+        lines.concat(finished_items.take(limit).map do |item|
+          item.to_s(indent_level: 1, stylize: stylize)
+        end)
+        lines << "#{Util::TAB}..." if total_finished > limit
+        lines << ""
+        lines.join("\n")
+      end
+
+      sig { params(limit: Integer, stylize: T::Boolean).returns(T.nilable(String)) }
+      def not_started_items_summary(limit: 5, stylize: false)
+        return if total_not_started < 1
+
+        lines = T.let([
+          "🌱 #{total_not_started} #{not_started_item_units} (#{not_started_percent}%) " \
+            "in Audible library have not been started:",
+        ], T::Array[String])
+        lines.concat(not_started_items.take(limit).map do |item|
+          item.to_s(indent_level: 1, stylize: stylize)
+        end)
+        lines << "#{Util::TAB}..." if total_not_started > limit
+        lines << ""
+        lines.join("\n")
+      end
+
+      sig { params(limit: Integer, stylize: T::Boolean).returns(T.nilable(String)) }
+      def started_items_summary(limit: 5, stylize: false)
+        return if total_started < 1
+
+        lines = T.let([
+          "🔜 #{total_started} #{started_item_units} (#{started_percent}%) in Audible " \
+            "library are in progress:",
+        ], T::Array[String])
+        lines.concat(started_items.take(limit).map do |item|
+          item.to_s(indent_level: 1, stylize: stylize)
+        end)
+        lines << "#{Util::TAB}..." if total_started > limit
+        lines << ""
+        lines.join("\n")
+      end
+
+      sig { params(limit: Integer, stylize: T::Boolean).returns(String) }
+      def to_s(limit: 5, stylize: false)
+        [
+          "📚 Loaded #{total_items} #{item_units} from Audible library",
+          not_started_items_summary(limit: limit, stylize: stylize),
+          finished_items_summary(limit: limit, stylize: stylize),
+          started_items_summary(limit: limit, stylize: stylize),
+        ].compact.join("\n")
+      end
+
+      private
+
+      sig { void }
+      def calculate_finished_unfinished_items
+        return if @finished_items && @unfinished_items
+        @finished_items, @unfinished_items = items.partition(&:finished?)
+        @finished_items.sort! do |a, b|
+          a_finish_time = a.finished_at
+          b_finish_time = b.finished_at
+          if a_finish_time && b_finish_time
+            T.must(b_finish_time <=> a_finish_time)
+          elsif a_finish_time
+            -1
+          elsif b_finish_time
+            1
+          else
+            0
+          end
+        end
+      end
+
+      sig { void }
+      def calculate_started_not_started_items
+        return if @started_items && @not_started_items
+        @started_items, @not_started_items = unfinished_items.partition(&:started?)
+        @started_items.sort! { |a, b| b.percent_complete <=> a.percent_complete }
+      end
+    end
+  end
+end