good_audible_story_sync 0.0.5

data/lib/good_audible_story_sync/storygraph/client.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+# typed: true
+
+require "mechanize"
+require "rainbow"
+
+module GoodAudibleStorySync
+  module Storygraph
+    class Client
+      extend T::Sig
+
+      BASE_URL = Auth::BASE_URL
+
+      class NotAuthenticatedError < StandardError; end
+      class Error < StandardError; end
+
+      sig { returns Mechanize }
+      attr_reader :agent
+
+      sig { params(auth: Auth).void }
+      def initialize(auth:)
+        @agent = T.let(auth.agent, Mechanize)
+        @auth = auth
+      end
+
+      sig { params(book_id: String, page: T.nilable(Mechanize::Page)).returns(T::Boolean) }
+      def mark_as_read(book_id, page: nil)
+        page ||= get_book_page(book_id)
+        action_regex = /book_id=#{book_id}&status=read/
+        form = page.forms.detect { |f| f.action =~ action_regex }
+        unless form
+          puts "#{Util::ERROR_EMOJI} Could not find form to mark book as read"
+          return false
+        end
+        form.submit
+        true
+      end
+
+      sig { params(book_id: String).returns(Mechanize::Page) }
+      def get_book_page(book_id)
+        page = get("/books/#{book_id}")
+        raise Error.new("Could not get book #{book_id}") unless page
+        page
+      end
+
+      sig { params(book_id: String, finish_date: Date).returns(T::Boolean) }
+      def set_read_date(book_id, finish_date)
+        page = get_book_page(book_id)
+        link = get_link_to_set_read_date(page)
+
+        if link.nil? && page.at(".read-status-label").nil?
+          puts "#{Util::INFO_EMOJI} Marking book as read..."
+          success = mark_as_read(book_id, page: page)
+          return false unless success
+
+          page = get_book_page(book_id)
+          link = get_link_to_set_read_date(page)
+        end
+
+        unless link
+          puts "#{Util::ERROR_EMOJI} Could not find link to show read-date form"
+          return false
+        end
+
+        update_file = T.let(link.click, Mechanize::File)
+        update_page = Mechanize::Page.new(page.uri, page.response, update_file.body, page.code, @agent)
+        action_regex = /^\/read_instances\//
+        form = update_page.forms.detect { |f| f.action =~ action_regex }
+        unless form
+          puts "#{Util::ERROR_EMOJI} Could not find form to update read date"
+          return false
+        end
+
+        end_day_field = form.field_with(name: "read_instance[day]")
+        unless end_day_field
+          puts "#{Util::ERROR_EMOJI} Could not find day field in read-date form"
+          return false
+        end
+
+        end_month_field = form.field_with(name: "read_instance[month]")
+        unless end_month_field
+          puts "#{Util::ERROR_EMOJI} Could not find month field in read-date form"
+          return false
+        end
+
+        end_year_field = form.field_with(name: "read_instance[year]")
+        unless end_year_field
+          puts "#{Util::ERROR_EMOJI} Could not find year field in read-date form"
+          return false
+        end
+
+        end_year_field.value = finish_date.year
+        end_month_field.value = finish_date.month
+        end_day_field.value = finish_date.day
+
+        form.submit
+
+        true
+      end
+
+      sig { params(book_id: String).returns(T::Boolean) }
+      def set_currently_reading(book_id)
+        page = get_book_page(book_id)
+        action_regex = /book_id=#{book_id}&status=currently-reading$/
+        form = page.forms.detect { |f| f.action =~ action_regex }
+        return false unless form
+        form.submit
+        true
+      end
+
+      sig { params(path: String).returns(T.nilable(Mechanize::Page)) }
+      def get(path)
+        url = "#{BASE_URL}#{path}"
+        puts "#{Util::INFO_EMOJI} GET #{Rainbow(url).blue}"
+        load_page(-> { @agent.get(url) })
+      end
+
+      # e.g., https://app.thestorygraph.com/books-read/cheshire137
+      sig do
+        params(
+          page: Integer,
+          load_all_pages: T::Boolean,
+          process_book: T.nilable(T.proc.params(arg0: Book).void)
+        ).returns(Library)
+      end
+      def get_read_books(page: 1, load_all_pages: true, process_book: nil)
+        initial_page = get("/books-read/#{@auth.username}?page=#{page}")
+        raise Error.new("Could not load page #{page} of read books") unless initial_page
+
+        filter_header_prefix = "Filter list "
+        filter_header_el = initial_page.search(".filter-menu *").detect do |el|
+          el.text.start_with?(filter_header_prefix)
+        end
+        total_books = if filter_header_el
+          filter_header_el.text.split(filter_header_prefix).last.gsub(/[^0-9]/, "").to_i
+        end
+
+        library = Library.new(total_books: total_books)
+        books = get_read_books_on_page(page: initial_page, load_all_pages: load_all_pages,
+          process_book: process_book)
+
+        books.each { |book| library.add_book(book) }
+        library
+      end
+
+      sig { params(isbn: String, fallback_query: T.nilable(String)).returns(T.nilable(Book)) }
+      def find_by_isbn(isbn, fallback_query: nil)
+        result_link = search(isbn).first
+        if result_link.nil? && fallback_query
+          puts "#{Util::WARNING_EMOJI} No results for ISBN #{isbn}, searching for '#{fallback_query}'"
+          result_link = search(fallback_query).first
+        end
+        return unless result_link
+
+        load_book_search_result(result_link, extra_data: { "isbn" => isbn })
+      end
+
+      sig { params(link: Mechanize::Page::Link, extra_data: T::Hash[String, T.untyped]).returns(Book) }
+      def load_book_search_result(link, extra_data: {})
+        page = link.click
+
+        other_edition_link = page.link_with(text: /You've read another edition/) ||
+          page.link_with(text: /You did not finish another edition/)
+        if other_edition_link
+          page = other_edition_link.click
+        end
+
+        Book.from_book_page(page, extra_data: extra_data)
+      end
+
+      # e.g., https://app.thestorygraph.com/search?search_term=midnight%20chernobyl
+      sig { params(query: String).returns(T::Array[Mechanize::Page::Link]) }
+      def search(query)
+        raise "No search query provided" if query.strip.empty?
+
+        params = { "search_term" => query }
+        page = get("/search?#{URI.encode_www_form(params)}")
+        raise Error.new("Could not load search results for '#{query}'") unless page
+
+        search_results_list = page.at("#search-results-ul")
+        return [] unless search_results_list
+
+        links = page.links.select { |link| link.node.ancestors.include?(search_results_list) }
+        links.reject { |link| link.text.strip.start_with?("View all results") }
+      end
+
+      private
+
+      sig { params(page: Mechanize::Page).returns(T.nilable(Mechanize::Page::Link)) }
+      def get_link_to_set_read_date(page)
+        page.link_with(text: /Click to add a read date/) ||
+          page.link_with(text: /Click to edit read date/)
+      end
+
+      sig { params(make_request: T.proc.returns(Mechanize::Page)).returns(T.nilable(Mechanize::Page)) }
+      def load_page(make_request)
+        page = begin
+          make_request.call
+        rescue Mechanize::ResponseCodeError => err
+          puts "#{Util::ERROR_EMOJI} Error loading page: #{err}"
+          return nil
+        end
+        raise NotAuthenticatedError if Auth.sign_in_page?(page)
+        sleep 1 # don't hammer the server
+        page
+      end
+
+      sig do
+        params(
+          path: T.nilable(String),
+          page: T.nilable(Mechanize::Page),
+          load_all_pages: T::Boolean,
+          process_book: T.nilable(T.proc.params(arg0: Book).void)
+        ).returns(T::Array[Book])
+      end
+      def get_read_books_on_page(path: nil, page: nil, load_all_pages: true, process_book: nil)
+        if path
+          page = get(path)
+          raise Error.new("Could not load read books via page #{path}") unless page
+        elsif page.nil?
+          raise "Either a relative URL or a page must be provided"
+        end
+
+        book_elements = T.let(page.search(".read-books-panes .book-pane"), Nokogiri::XML::NodeSet)
+        books = book_elements.map { |book_element| Book.from_read_book(book_element, page: page) }
+        puts "#{Util::WARNING_EMOJI} No books found on #{page.uri}" if books.empty?
+        books.each { |book| process_book.call(book) } if process_book
+
+        if load_all_pages
+          next_page_link = page.at(".read-books #next_link")
+          if next_page_link
+            units = books.size == 1 ? "book" : "books"
+            print "#{Util::INFO_EMOJI} Found #{books.size} #{units} on page"
+            last_book = books.last
+            print ", ending with #{last_book.title_and_author}" if last_book
+            puts
+
+            books += get_read_books_on_page(path: next_page_link["href"],
+              load_all_pages: load_all_pages, process_book: process_book)
+          end
+        end
+
+        books
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/storygraph/library.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+# typed: true
+
+module GoodAudibleStorySync
+  module Storygraph
+    class Library
+      extend T::Sig
+
+      SYNC_TIME_KEY = "storygraph_library"
+
+      sig { params(client: Client, db_client: Database::Client, options: Options).returns(Library) }
+      def self.load(client:, db_client:, options:)
+        library_cache_last_modified = db_client.sync_times.find(SYNC_TIME_KEY)&.to_time
+        library_is_cached = !library_cache_last_modified.nil?
+        should_refresh_library = library_cache_last_modified &&
+          library_cache_last_modified > options.refresh_cutoff_time
+
+        if library_is_cached && should_refresh_library
+          load_from_database(db_client.storygraph_books)
+        else
+          if library_is_cached
+            puts "#{Util::INFO_EMOJI} Storygraph library cache has not been updated " \
+              "since #{Util.pretty_time(library_cache_last_modified)}, updating..."
+          end
+          load_from_web(client: client, db_client: db_client)
+        end
+      end
+
+      sig { params(client: Client, db_client: Database::Client).returns(Library) }
+      def self.load_from_web(client:, db_client:)
+        books_db = db_client.storygraph_books
+        save_book = T.let(
+          ->(book) { book.save_to_database(books_db) },
+          T.proc.params(arg0: GoodAudibleStorySync::Storygraph::Book).void
+        )
+        begin
+          library = client.get_read_books(process_book: save_book)
+          library.update_sync_time(db_client.sync_times)
+          library
+        rescue Client::Error => err
+          puts "#{Util::ERROR_EMOJI} Error loading Storygraph library: #{err}"
+          exit 1
+        end
+      end
+
+      sig { params(books_db: Database::StorygraphBooks).returns(Library) }
+      def self.load_from_database(books_db)
+        library = new
+        library.load_from_database(books_db)
+        library
+      end
+
+      sig { params(total_books: T.nilable(Integer)).void }
+      def initialize(total_books: nil)
+        @books_by_id = T.let({}, T::Hash[String, Book])
+        @total_books = total_books
+      end
+
+      sig { returns T::Array[Book] }
+      def books
+        @books_by_id.values
+      end
+
+      sig { params(book: Book).void }
+      def add_book(book)
+        id = book.id
+        raise "Cannot add book without ID" unless id
+
+        existing_book = @books_by_id[id]
+        @books_by_id[id] = if existing_book
+          existing_book.copy_from(book)
+          existing_book
+        else
+          book
+        end
+      end
+
+      sig { params(book: Book).void }
+      def remove_book(book)
+        book_id = book.id
+        @books_by_id.delete(book_id) if book_id
+      end
+
+      sig { returns Integer }
+      def total_books
+        @total_books || @books_by_id.size
+      end
+
+      sig { returns Integer }
+      def finished_percent
+        @finished_percent ||= (total_finished.to_f / total_books * 100).round
+      end
+
+      sig { returns String }
+      def finished_book_units
+        total_finished == 1 ? "book" : "books"
+      end
+
+      sig { returns String }
+      def book_units
+        total_books == 1 ? "book" : "books"
+      end
+
+      sig { params(books_db: Database::StorygraphBooks).returns(T::Boolean) }
+      def load_from_database(books_db)
+        puts "#{Util::INFO_EMOJI} Loading cached Storygraph library..."
+
+        rows = books_db.find_all
+        rows.each { |row| add_book(Book.new(row)) }
+
+        true
+      end
+
+      sig { params(sync_times_db: Database::SyncTimes).void }
+      def update_sync_time(sync_times_db)
+        puts "#{Util::SAVE_EMOJI} Updating time Storygraph library was last cached..."
+        sync_times_db.touch(SYNC_TIME_KEY)
+      end
+
+      sig { params(limit: Integer, stylize: T::Boolean).returns(String) }
+      def to_s(limit: 5, stylize: false)
+        [
+          "📚 Found #{total_books} #{book_units} on Storygraph",
+          finished_books_summary(limit: limit, stylize: stylize),
+        ].compact.join("\n")
+      end
+
+      sig { params(limit: Integer, stylize: T::Boolean).returns(String) }
+      def finished_books_summary(limit: 5, stylize: false)
+        lines = T.let([
+          "#{Util::DONE_EMOJI} #{total_finished} #{finished_book_units} " \
+            "(#{finished_percent}%) in Storygraph library have been finished:",
+        ], T::Array[String])
+        lines.concat(finished_books.take(limit).map { |book| book.to_s(indent_level: 1, stylize: stylize) })
+        lines << "#{Util::TAB}..." if total_finished > limit
+        lines << ""
+        lines.join("\n")
+      end
+
+      sig { returns Integer }
+      def total_finished
+        @total_finished ||= finished_books.size
+      end
+
+      sig { returns T::Array[Book] }
+      def finished_books
+        calculate_finished_unfinished_books
+        @finished_books
+      end
+
+      sig { returns String }
+      def to_json
+        JSON.pretty_generate(books.map(&:to_h))
+      end
+
+      sig { params(isbn: String).returns(T.nilable(Book)) }
+      def find_by_isbn(isbn)
+        books.detect { |book| book.isbn == isbn }
+      end
+
+      private
+
+      sig { void }
+      def calculate_finished_unfinished_books
+        return if @finished_books && @unfinished_books
+        @finished_books, @unfinished_books = books.partition(&:finished?)
+        @finished_books.sort! do |a, b|
+          a_finish_date = a.finished_on
+          b_finish_date = b.finished_on
+          if a_finish_date && b_finish_date
+            T.must(b_finish_date <=> a_finish_date)
+          elsif a_finish_date
+            -1
+          elsif b_finish_date
+            1
+          else
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/storygraph/look_up_book_flow.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+# typed: true
+
+require "rainbow"
+
+module GoodAudibleStorySync
+  module Storygraph
+    class LookUpBookFlow
+      extend T::Sig
+
+      class UserCommand < T::Enum
+        enums do
+          Cancel = new("c")
+          Quit = new("q")
+        end
+      end
+
+      sig { params(client: Client, books_db: Database::StorygraphBooks).void }
+      def self.run(client:, books_db:)
+        new(client: client, books_db: books_db).run
+      end
+
+      sig { params(client: Client, books_db: Database::StorygraphBooks).void }
+      def initialize(client:, books_db:)
+        @client = client
+        @books_db = books_db
+        @results = T.let([], T::Array[Mechanize::Page::Link])
+        @query = T.let(nil, T.nilable(String))
+      end
+
+      sig { void }
+      def run
+        loop do
+          print_options
+          cmd_or_query = get_user_command_or_query
+          if cmd_or_query.is_a?(UserCommand)
+            process_command(cmd_or_query)
+          else
+            @query = cmd_or_query
+            search_storygraph
+          end
+          puts
+        end
+      end
+
+      private
+
+      sig { void }
+      def print_options
+        display_search_results if @results.size > 0
+        print_option(UserCommand::Cancel, "cancel")
+        print_option(UserCommand::Quit, "quit")
+      end
+
+      sig { params(option: UserCommand, description: String).void }
+      def print_option(option, description)
+        Util.print_option(option.serialize, description)
+      end
+
+      sig { returns T.any(UserCommand, String) }
+      def get_user_command_or_query
+        input = T.let(nil, T.nilable(String))
+        while input.nil?
+          print "Enter a search query or command: "
+          input = gets.chomp
+          if input.empty?
+            puts "Invalid selection"
+          else
+            cmd = UserCommand.try_deserialize(input)
+            return cmd if cmd
+          end
+        end
+        input
+      end
+
+      sig { params(cmd: UserCommand).void }
+      def process_command(cmd)
+        case cmd
+        when UserCommand::Cancel then cancel
+        when UserCommand::Quit then quit
+        else
+          T.absurd(cmd)
+        end
+      end
+
+      sig { params(selection: String).void }
+      def process_search_result_selection(selection)
+        unless Util.integer?(selection)
+          puts "#{Util::ERROR_EMOJI} Invalid selection"
+          return
+        end
+
+        index = selection.to_i - 1
+        result = @results[index]
+        unless result
+          puts "#{Util::ERROR_EMOJI} Invalid selection"
+          return
+        end
+
+        extra_data = {}
+        if @query && Util.isbn?(@query)
+          extra_data["isbn"] = @query
+        end
+        book = @client.load_book_search_result(result, extra_data: extra_data)
+        book.save_to_database(@books_db)
+        puts book.to_s(stylize: true)
+        @results = []
+        @query = nil
+      end
+
+      sig { void }
+      def search_storygraph
+        raise "No search query provided" if @query.nil?
+        @results = @client.search(@query)
+        if @results.empty?
+          puts "#{Util::INFO_EMOJI} No results found for \"#{@query}\""
+          return
+        end
+        prompt_user_to_pick_search_result
+      end
+
+      sig { void }
+      def display_search_results
+        total_results = @results.size
+        units = total_results == 1 ? "result" : "results"
+        puts "#{Util::INFO_EMOJI} Showing #{total_results} search #{units}:"
+        @results.each_with_index do |link, i|
+          display_search_result(link, i + 1)
+        end
+      end
+
+      sig { params(link: Mechanize::Page::Link, number: Integer).void }
+      def display_search_result(link, number)
+        node = link.node
+        title = Util.squish(node.at("h1:not(.sr-only)")&.text)
+        author = Util.squish(node.at("h2:not(.sr-only)")&.text)
+        highlighted_number = Rainbow(number.to_s).green
+        print "#{highlighted_number}) "
+        if title && author
+          puts Rainbow(title).underline + " by #{author}"
+        else
+          puts link.text
+        end
+        url = Rainbow(link.resolved_uri.to_s).blue
+        puts "#{Util::TAB}#{Util::NEWLINE_EMOJI} #{url}"
+      end
+
+      sig { void }
+      def prompt_user_to_pick_search_result
+        print_options
+        print "Make a selection: "
+        input = gets.chomp
+        cmd = UserCommand.try_deserialize(input)
+        if cmd
+          process_command(cmd)
+        else
+          process_search_result_selection(input)
+        end
+      end
+
+      sig { void }
+      def cancel
+      end
+
+      sig { void }
+      def quit
+        puts "Goodbye!"
+        exit 0
+      end
+    end
+  end
+end