furaffinity 0.1.0

data/README.md

@@ -0,0 +1,84 @@
+# furaffinity
+
+A gem to interface with FurAffinity, along with a neat little CLI.
+
+## Installation
+
+```sh
+gem install furaffinity
+```
+
+## Usage
+
+CLI usage is as follows:
+
+```sh
+# replace "cookie-a" and "cookie-b" with the values of the respective cookies
+# use firefox's web inspector for that, the "Storage" tab displays it nicely
+fa auth cookie-a cookie-b
+
+# retrieve your notification counters as JSON
+fa notifications
+# {
+#   "submissions": 30944,
+#   "watches": 317,
+#   "comments": 278,
+#   "favourites": 1018,
+#   "journals": 1642,
+#   "trouble_tickets": 9
+# }
+
+# upload a new submission
+fa upload my_image.png --title "test post please ignore" --description "This is an image as you can see" --rating general --scrap
+```
+
+There is also a way to upload submissions in bulk: `fa queue`
+
+```sh
+# set your preferred editor in ENV
+export EDITOR=vi
+
+# initialise queue directory
+fa queue init my_queue
+cd my_queue
+
+# copy files to upload into the queue directory
+cp ~/Pictures/pic*.png .
+
+# add files, an editor will open up for each file to fill in the details
+fa queue add pic1.png
+fa queue add pic2.png pic3.png
+
+# see the status of the queue
+fa queue status
+
+# use your preferred editor to change the submission information afterwards
+vi pic2.png.info.yml
+
+# open up an editor to rearrange the queue order
+fa queue reorder
+
+# upload the entire queue
+fa queue upload
+
+# once everything's uploaded you can remove the already uploaded pics
+fa queue clean
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nilsding/furaffinity. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/nilsding/furaffinity/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [AGPLv3 License](https://opensource.org/license/agpl-v3/).
+
+## Code of Conduct
+
+Everyone interacting in the Furaffinity project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/nilsding/furaffinity/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+task :default

data/exe/fa

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+lib_dir = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require "furaffinity"
+
+SemanticLogger.sync!
+SemanticLogger.add_appender(io: $stdout, formatter: :color)
+
+Furaffinity::Cli.start

data/lib/furaffinity/cli.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "json"
+require "thor"
+
+module Furaffinity
+  class Cli < Thor
+    include CliBase
+
+    class_option :log_level,
+      type:    :string,
+      desc:    "Log level to use",
+      default: "info"
+
+    class_option :config,
+      type:    :string,
+      desc:    "Path to the config",
+      default: File.join(Dir.home, ".farc")
+
+    desc "auth A_COOKIE B_COOKIE", "Store authentication info for FurAffinity"
+    def auth(a_cookie, b_cookie)
+      set_log_level(options)
+      config = config_for(options)
+      config.set!(a: a_cookie, b: b_cookie)
+      say "Authentication info stored.", :green
+    end
+
+    desc "notifications", "Get the current notification counters as JSON"
+    def notifications
+      set_log_level(options)
+      config = config_for(options)
+      client = config.new_client
+
+      puts JSON.pretty_generate client.notifications
+    end
+
+    desc "upload FILE_PATH", "Upload a new submission"
+    option :type,
+      type:    :string,
+      desc:    "Submission type.  One of: #{Furaffinity::Client::SUBMISSION_TYPES.join(", ")}",
+      default: "submission"
+    option :title,
+      type:     :string,
+      desc:     "Submission title.",
+      required: true
+    option :description,
+      type:     :string,
+      desc:     "Submission description.",
+      required: true
+    option :rating,
+      type:     :string,
+      desc:     "Submission rating.  One of: #{Furaffinity::Client::RATING_MAP.keys.join(", ")}",
+      required: true
+    option :lock_comments,
+      type:    :boolean,
+      desc:    "Disable comments on this submission.",
+      default: false
+    option :scrap,
+      type:    :boolean,
+      desc:    "Place this upload to your scraps.",
+      default: false
+    option :keywords,
+      type:    :string,
+      desc:    "Keywords, separated by spaces.",
+      default: ""
+    option :folder_name,
+      type:    :string,
+      desc:    "Place this submission into this folder.",
+      default: ""
+    def upload(file_path)
+      set_log_level(options)
+      config = config_for(options)
+      client = config.new_client
+
+      upload_options = options.slice(
+        *client
+          .method(:upload)
+          .parameters
+          .select { |(type, name)| %i[keyreq key].include?(type) }
+          .map(&:last)
+      ).transform_keys(&:to_sym)
+      url = client.upload(File.new(file_path), **upload_options)
+      say "Submission uploaded!  #{url}", :green
+    end
+
+    desc "queue SUBCOMMAND ...ARGS", "Manage an upload queue"
+    long_desc <<~LONG_DESC, wrap: false
+      `#{basename} queue` manages an upload queue.
+
+      It behaves somewhat like `git`, where you have to initialise a designated
+      directory first for it to use as a queue.
+
+      An example workflow with `#{basename} queue` would look like:
+
+          # set your preferred editor in ENV
+          export EDITOR=vi
+
+          # initialise queue directory
+          #{basename} queue init my_queue
+          cd my_queue
+
+          # copy files to upload into the queue directory
+          cp ~/Pictures/pic*.png .
+
+          # add files, an editor will open up for each file to fill in the details
+          #{basename} queue add pic1.png
+          #{basename} queue add pic2.png pic3.png
+
+          # see the status of the queue
+          #{basename} queue status
+
+          # use your preferred editor to change the submission information afterwards
+          vi pic2.png.info.yml
+
+          # open up an editor to rearrange the queue order
+          #{basename} queue reorder
+
+          # upload the entire queue
+          #{basename} queue upload
+
+          # once everything's uploaded you can remove the already uploaded pics
+          #{basename} queue clean
+    LONG_DESC
+    subcommand "queue", CliQueue
+  end
+end

data/lib/furaffinity/cli_base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Furaffinity
+  module CliBase
+    def self.included(base)
+      def base.exit_on_failure? = true
+    end
+
+    private
+
+    def set_log_level(options)
+      SemanticLogger.default_level = options[:log_level].to_sym
+    end
+
+    def config_for(options) = Config.new(options[:config])
+  end
+end

data/lib/furaffinity/cli_queue.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Furaffinity
+  class CliQueue < Thor
+    include CliBase
+
+    desc "init [DIR]", "Initialise a queue directory"
+    def init(dir = Dir.pwd)
+      result = queue(dir).init
+      say "Created new queue dir in #{result.inspect}", :green
+    rescue Furaffinity::Error => e
+      say e.message, :red
+      exit 1
+    end
+
+    desc "add FILE...", "Add a file to the upload queue"
+    def add(*files)
+      if files.empty?
+        say "You need to pass a file.", :red
+        help :add
+        exit 1
+      end
+
+      queue.reload
+
+      files_added = queue.add(*files)
+      files_added.each do |file|
+        say "added #{file.inspect}", :green
+      end
+    rescue Furaffinity::Error => e
+      say e.message, :red
+      exit 1
+    end
+
+    desc "remove FILE...", "Removes a file from the upload queue"
+    def remove(*files)
+      if files.empty?
+        say "You need to pass a file.", :red
+        help :remove
+        exit 1
+      end
+
+      queue.reload
+
+      files_removed = queue.remove(*files)
+      files_removed.each do |file|
+        say "removed #{file.inspect}", :green
+      end
+    rescue Furaffinity::Error => e
+      say e.message, :red
+      exit 1
+    end
+
+    desc "clean", "Remove uploaded files"
+    def clean
+      queue.reload
+      queue.clean
+      say "Removed uploaded files", :green
+    rescue Furaffinity::Error => e
+      say e.message, :red
+      exit 1
+    end
+
+    desc "reorder", "Open an editor to rearrange the queue"
+    def reorder
+      queue.reload
+      queue.reorder unless queue.queue.empty?
+
+      invoke :status
+    end
+
+    desc "status", "Print the current status of the queue"
+    def status
+      queue.reload
+
+      if queue.queue.empty?
+        say "Nothing is in the queue yet, use `#{File.basename $0} queue add ...` to add files.", :yellow
+
+        print_uploaded_files
+        return
+      end
+
+      say "Enqueued files:"
+      queue_table = [["Position", "File name", "Title", "Rating"], :separator]
+      queue.queue.each_with_index do |file_name, idx|
+        file_info = queue.file_info.fetch(file_name)
+        queue_table << [idx + 1, file_name, file_info[:title], file_info[:rating]]
+      end
+      print_table queue_table, borders: true
+
+      print_uploaded_files
+
+    rescue Furaffinity::Error => e
+      say e.message, :red
+      exit 1
+    end
+
+    desc "upload", "Upload all submissions in the queue."
+    option :wait_time, type: :numeric, desc: "Seconds to wait between each upload.", default: 60
+    def upload
+      if options[:wait_time] < 30
+        say "--wait-time must be at least 30", :red
+        exit 1
+      end
+
+      queue.reload
+      queue.upload(options[:wait_time])
+      say "Submissions uploaded.", :green
+    rescue Furaffinity::Error => e
+      say e.message, :red
+      exit 1
+    end
+
+    private
+
+    def queue(dir = Dir.pwd)
+      @queue ||= begin
+        set_log_level(options)
+        config = config_for(options)
+        Queue.new(config.new_client, dir)
+      end
+    end
+
+    def print_uploaded_files
+      uploaded_files = queue.uploaded_files
+      unless uploaded_files.empty?
+        say
+        say "Uploaded files (will be removed when you run `#{File.basename $0} queue clean`):"
+        uploaded_table = [["File name", "Title", "Submission URL"], :separator]
+        uploaded_files.each do |file_name, upload_status|
+          file_info = queue.file_info.fetch(file_name)
+          uploaded_table << [file_name, file_info[:title], upload_status[:url]]
+        end
+        print_table uploaded_table, borders: true
+      end
+    end
+  end
+end

data/lib/furaffinity/client.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "httpx"
+require "nokogiri"
+
+module Furaffinity
+  class Client
+    include SemanticLogger::Loggable
+
+    BASE_URL = "https://www.furaffinity.net"
+
+    # @param a [String] value of the `a` cookie
+    # @param b [String] value of the `b` cookie
+    def initialize(a:, b:)
+      raise Error.new("a needs to be a non-zero string") unless a.is_a?(String) || a.empty?
+      raise Error.new("b needs to be a non-zero string") unless b.is_a?(String) || b.empty?
+
+      @auth_cookies = { "a" => a, "b" => b }
+    end
+
+    def http_client
+      HTTPX
+        .plugin(:cookies)
+        .plugin(:stream)
+        # .plugin(:follow_redirects)
+        .with(headers: { "user-agent" => "furaffinity/#{Furaffinity::VERSION} (Ruby)" })
+        .with_cookies(@auth_cookies)
+    end
+
+    def get(path, client: nil)
+      client ||= http_client
+      url = File.join(BASE_URL, path)
+      logger.measure_trace("GET #{url}") do
+        client.get(url)
+      end
+    end
+
+    def post(path, form: {}, client: nil)
+      client ||= http_client
+      url = File.join(BASE_URL, path)
+      logger.measure_trace("POST #{url}", { form: }) do
+        client.post(url, form:)
+      end
+    end
+
+    NOTIFICATIONS_MAP = {
+      "submission"    => :submissions,
+      "watch"         => :watches,
+      "comment"       => :comments,
+      "favorite"      => :favourites,
+      "journal"       => :journals,
+      "unread"        => :notes,
+      "troubleticket" => :trouble_tickets,
+    }
+
+    def notifications
+      get("/")
+        .then(&method(:parse_response))
+        .css("a.notification-container")
+        .map { _1.attr(:title) }
+        .uniq
+        .each_with_object({}) do |item, h|
+          count, type, *_rest = item.split(" ")
+          count = count.tr(",", "").strip.to_i
+          h[NOTIFICATIONS_MAP.fetch(type.downcase.strip)] = count
+        end
+    end
+
+    SUBMISSION_TYPES = %i[submission story poetry music].freeze
+    RATING_MAP = {
+      general: 0,
+      mature:  2,
+      adult:   1,
+    }.freeze
+
+    def fake_upload(file, title:, rating:, description:, keywords:, folder_name: "", lock_comments: false, scrap: false, type: :submission)
+      type = type.to_sym
+      raise ArgumentError.new("#{type.inspect} is not in #{SUBMISSION_TYPES.inspect}") unless SUBMISSION_TYPES.include?(type)
+      rating = rating.to_sym
+      raise ArgumentError.new("#{rating.inspect} is not in #{RATING_MAP.keys.inspect}") unless RATING_MAP.include?(rating)
+      raise "not a file" unless file.is_a?(File)
+      params = { MAX_FILE_SIZE: "10485760" }
+      raise ArgumentError.new("file size of #{file.size} is greater than FA limit of #{params[:MAX_FILE_SIZE]}") if file.size > params[:MAX_FILE_SIZE].to_i
+      "https://..."
+    end
+
+    # @param file [File]
+    def upload(file, title:, rating:, description:, keywords:, folder_name: "", lock_comments: false, scrap: false, type: :submission)
+      type = type.to_sym
+      raise ArgumentError.new("#{type.inspect} is not in #{SUBMISSION_TYPES.inspect}") unless SUBMISSION_TYPES.include?(type)
+      rating = rating.to_sym
+      raise ArgumentError.new("#{rating.inspect} is not in #{RATING_MAP.keys.inspect}") unless RATING_MAP.include?(rating)
+
+      client = http_client
+
+      # step 1: get the required keys
+      logger.trace "Extracting keys from upload form"
+      response = get("/submit/", client:).then(&method(:parse_response))
+      params = {
+        submission_type: type,
+        submission:      file,
+        thumbnail:       {
+          content_type: "application/octet-stream",
+          filename: "",
+          body: ""
+        },
+      }
+      params.merge!(
+        %w[MAX_FILE_SIZE key]
+          .map { [_1.to_sym, response.css("form#myform input[name=#{_1}]").first.attr(:value)] }
+          .to_h
+      )
+      raise ArgumentError.new("file size of #{file.size} is greater than FA limit of #{params[:MAX_FILE_SIZE]}") if file.size > params[:MAX_FILE_SIZE].to_i
+
+      # step 2: upload the submission file
+      logger.debug "Uploading submission..."
+      upload_response = post("/submit/upload/", form: params, client:)
+      # for some reason HTTPX performs a GET redirect with the params so we
+      # can't use its plugin here
+      # --> follow the redirect ourselves
+      raise Error.new("expected a 302 response, got #{upload_response.status}") unless upload_response.status == 302
+
+      redirect_location = upload_response.headers[:location]
+      unless redirect_location == "/submit/finalize/"
+        logger.warn "unexpected redirect target #{redirect_location.inspect}, expected \"/submit/finalize/\".  continuing regardless ..."
+      end
+      response = get(redirect_location, client:).then(&method(:parse_response))
+
+      params = {
+        key: response.css("form#myform input[name=key]").first.attr(:value),
+
+        # category, "1" is "Visual Art -> All"
+        cat: "1",
+        # theme, "1" is "General Things -> All"
+        atype: "1",
+        # species, "1" is "Unspecified / Any"
+        species: "1",
+        # gender, "0" is "Any"
+        gender: "0",
+
+        rating:   RATING_MAP.fetch(rating),
+        title:    title,
+        message:  description,
+        keywords: keywords,
+
+        create_folder_name: folder_name,
+
+        # finalize button :)
+        finalize: "Finalize ",
+      }
+      params[:lock_comments] = "1" if lock_comments
+      params[:scrap] = "1" if scrap
+
+      logger.debug "Finalising submission..."
+      finalize_response = post("/submit/finalize/", form: params, client:)
+      if finalize_response.status == 302
+        redirect_location = finalize_response.headers[:location]
+        url = File.join(BASE_URL, redirect_location)
+        logger.info "Uploaded! #{url}"
+        return url
+      else
+        fa_error = parse_response(finalize_response).css(".redirect-message").text
+        raise Error.new("FA returned: #{fa_error}")
+      end
+    end
+
+    private
+
+    def parse_response(httpx_response)
+      logger.measure_trace "Parsing response" do
+        Nokogiri::HTML.parse(httpx_response)
+      end
+    end
+  end
+end

data/lib/furaffinity/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Furaffinity
+  class Config
+    include SemanticLogger::Loggable
+
+    def initialize(path)
+      @path = path
+      if File.exist?(path)
+        logger.measure_trace("Loading configuration") do
+          @config_hash = YAML.safe_load_file(path)
+        end
+      else
+        @config_hash = {}
+      end
+    rescue => e
+      logger.fatal("Error while loading configuration:", e)
+      raise
+    end
+
+    # @return [Furaffinity::Client]
+    def new_client = Furaffinity::Client.new(a: self[:a], b: self[:b])
+
+    def [](key) = @config_hash[key.to_s]
+    alias get []
+
+    def []=(key, value)
+      @config_hash[key.to_s] = value
+    end
+
+    def set(**kwargs)
+      kwargs.each do |k, v|
+        self[k] = v
+      end
+    end
+
+    def set!(**kwargs)
+      set(**kwargs)
+      save
+    end
+
+    def save
+      logger.measure_debug("Saving configuration") do
+        yaml = @config_hash.to_yaml
+        File.open(@path, "w") do |f|
+          f.puts yaml
+        end
+      end
+    end
+  end
+end