redux-scraper/app/models/domain/user/fa_user.rb

# typed: strict
class Domain::User::FaUser < Domain::User
  attr_json :state, :string
  attr_json :name, :string
  attr_json :url_name, :string
  attr_json :full_name, :string
  attr_json :account_status, :string
  attr_json :artist_type, :string
  attr_json :mood, :string
  attr_json :profile_html, :string
  attr_json :num_pageviews, :integer
  attr_json :num_submissions, :integer
  attr_json :num_comments_recieved, :integer
  attr_json :num_comments_given, :integer
  attr_json :num_journals, :integer
  attr_json :num_favorites, :integer
  attr_json_due_timestamp :scanned_gallery_at, 1.year
  attr_json_due_timestamp :scanned_page_at, 1.month
  attr_json_due_timestamp :scanned_follows_at, 1.month
  attr_json_due_timestamp :scanned_favs_at, 1.month
  attr_json_due_timestamp :scanned_incremental_at, 1.month
  attr_json :registered_at, :datetime
  attr_json :migrated_followed_users_at, :datetime
  attr_json :last_user_page_id, :integer
  attr_json :last_gallery_page_id, :integer
  attr_json :page_scan_error, :string
  attr_json :is_disabled, :boolean

  has_followed_users! Domain::User::FaUser
  has_followed_by_users! Domain::User::FaUser
  has_created_posts! Domain::Post::FaPost
  has_faved_posts! Domain::Post::FaPost

  belongs_to :last_user_page_log_entry,
             foreign_key: :last_user_page_id,
             class_name: "::HttpLogEntry",
             optional: true

  belongs_to :last_gallery_page_log_entry,
             foreign_key: :last_gallery_page_id,
             class_name: "::HttpLogEntry",
             optional: true

  enum :state,
       { ok: "ok", account_disabled: "account_disabled", error: "error" },
       prefix: :state

  validates :name, presence: true
  validates :url_name, presence: true
  validates :state, presence: true

  validates :account_status,
            inclusion: {
              in: %w[ok account_disabled error],
              allow_nil: true,
            }

  after_initialize { self.state ||= "ok" if new_record? }

  sig { override.returns([String, Symbol]) }
  def self.param_prefix_and_attribute
    ["fa", :url_name]
  end

  sig { void }
  def thing
    Domain::User::FaUser.where(url_name: "test")
  end

  sig { override.returns(String) }
  def self.view_prefix
    "fa"
  end

  sig { override.returns(String) }
  def description_html_base_domain
    "furaffinity.net"
  end

  sig { override.returns(T.nilable(String)) }
  def description_html_for_view
    profile_html
  end

  sig { override.returns(T::Array[String]) }
  def names_for_search
    [name, url_name, full_name].compact
  end

  sig do
    params(
      submission_parser:
        T.any(
          Domain::Fa::Parser::ListedSubmissionParserHelper,
          Domain::Fa::Parser::SubmissionParserHelper,
        ),
    ).returns(Domain::User::FaUser)
  end
  def self.find_or_build_from_submission_parser(submission_parser)
    find_or_initialize_by(url_name: submission_parser.artist_url_name) do |user|
      user.name = submission_parser.artist
    end
  end

  # TODO - write a test for this
  sig { override.returns(String) }
  def account_status_for_view
    as =
      account_status ||
        begin
          if (hle = guess_last_user_page_log_entry) &&
               (contents = hle.response_bytes)
            parser =
              Domain::Fa::Parser::Page.new(contents, require_logged_in: false)
            parser.user_page.account_status.to_s if parser.probably_user_page?
          end
        end || "unknown"
    as.titlecase
  end

  sig { returns(String) }
  def account_state_for_view
    case state
    when "ok"
      "Ok"
    when "account_disabled"
      "Disabled"
    when "error"
      "Error"
    else
      "Unknown"
    end
  end

  sig { returns(T.nilable(HttpLogEntry)) }
  def guess_last_user_page_log_entry
    last_user_page_log_entry ||
      HttpLogEntry.find_by_uri_host_path(
        "https://www.furaffinity.net/user/#{url_name}/",
      ) ||
      HttpLogEntry.find_by_uri_host_path(
        "https://www.furaffinity.net/user/#{url_name}",
      )
  end

  sig { override.returns(T.nilable(String)) }
  def external_url_for_view
    "https://www.furaffinity.net/user/#{url_name}" if url_name.present?
  end

  sig { override.returns(T.nilable(ActiveSupport::TimeWithZone)) }
  def registered_at_for_view
    registered_at
  end

  sig { override.returns(T.nilable(String)) }
  def name_for_view
    name || url_name
  end
end