xxx_rename 0.0.1

data/lib/xxx_rename/site_clients/stash_db.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/stash_db"
+
+module XxxRename
+  module SiteClients
+    class StashDb < Base
+      include HTTParty
+      include Utils
+
+      base_uri "https://stashdb.org"
+      headers "Content-Type" => "application/json"
+
+      site_client_name :stash
+
+      LOGIN_ENDPOINT = "/login"
+      GRAPHQL_ENDPOINT = "/graphql"
+
+      attr_reader :username, :password
+
+      def initialize(config)
+        @cookie_set = false
+        @api_key_set = false
+        super(config)
+      end
+
+      # @param [String] filename
+      # @return [XxxRename::Data::SceneData, nil]
+      def search(filename)
+        setup_credentials! if login_required?
+
+        match = search_query(filename)
+        search_string = if match.female_actors.empty?
+                          match.title
+                        else
+                          "#{match.female_actors.join(", ")} - #{match.title}"
+                        end
+        search_results = graphql_search(search_string, 10)
+        find_result_in_search_resp(search_results, match)
+      end
+
+      def setup_credentials!
+        if username_password_provided?
+          login_using_credentials(site_config.username, site_config.password)
+        elsif api_key_provided?
+          register_api_key(site_config.api_token)
+          validate_credentials!
+        else
+          raise Errors::InvalidCredentialsError, self.class.name
+        end
+      end
+
+      def actor_details(actor)
+        return unless credentials_provided?
+
+        setup_credentials! if login_required?
+        response = handle_response! { self.class.post(GRAPHQL_ENDPOINT, body: actor_search_query(actor)) }
+        response.dig("data", "searchPerformer")&.select { |x| match?(x["name"], actor) }&.first
+      end
+
+      private
+
+      def login_using_credentials(username, password)
+        body = { username: username, password: password }
+        resp = handle_response!(return_raw: true) { self.class.post(LOGIN_ENDPOINT, body: body, multipart: true) }
+        cookie_hash = HTTParty::CookieHash.new
+        resp.get_fields("Set-Cookie").each { |c| cookie_hash.add_cookies(c) }
+        @cookie_set = true
+        cookie_s = cookie_hash.to_cookie_string
+        self.class.headers "cookie" => cookie_s
+        cookie_s
+      end
+
+      def login_required?
+        true unless @cookie_set || @api_key_set
+      end
+
+      def register_api_key(api_key)
+        @api_key_set = true
+        self.class.headers "ApiKey" => api_key
+      end
+
+      def credentials_provided?
+        username_password_provided? || api_key_provided?
+      end
+
+      def username_password_provided?
+        [site_config.username, site_config.password].map(&:to_s).map(&:presence).all?(String)
+      end
+
+      def api_key_provided?
+        site_config.api_token.to_s.presence.is_a?(String)
+      end
+
+      def validate_credentials!
+        body = {
+          operationName: "Version",
+          query: <<~GRAPHQL
+            query Version {
+              version {
+                version
+              }
+            }
+          GRAPHQL
+        }.to_json
+        resp = handle_response! { self.class.post(GRAPHQL_ENDPOINT, body: body) }
+        resp.dig("data", "version", "version")
+      end
+
+      # @param [String] filename
+      # @return [XxxRename::SiteClients::QueryGenerator::Base::SearchParameters]
+      # @raise XxxRename::Errors::NoMatchError
+      def search_query(filename)
+        resp = SiteClients::QueryGenerator::StashDb.generate(filename, source_format)
+
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) if resp.nil?
+
+        resp
+      end
+
+      # @param [String] term
+      # @param [Integer] limit
+      # @return [Array[Hash]]
+      # @raise XxxRename::SearchError
+      def graphql_search(term, limit)
+        resp = self.class.post(GRAPHQL_ENDPOINT, body: grapql_body(term, limit))
+        if resp.code != 200
+          opts = { request_options: nil, response_code: resp.code, response_body: resp.body }
+          raise Errors::SearchError.new(term, opts)
+        end
+
+        resp.parsed_response.dig("data", "searchScene") || []
+      end
+
+      def find_result_in_search_resp(api_resp, match_data)
+        matched_scene = api_resp.select do |x|
+          condition1 = match?(x["title"], match_data.title) || match?(x.dig("studio", "name"), match_data.title)
+          condition2 = female_actors_included?(x, match_data.female_actors)
+          condition1 && condition2
+        end.first
+
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, match_data.title) if matched_scene.nil?
+
+        Data::SceneData.new(
+          female_actors: female_actors(matched_scene),
+          male_actors: male_actors(matched_scene),
+          actors: female_actors(matched_scene) + male_actors(matched_scene),
+          id: matched_scene["id"],
+          collection_tag: site_config.collection_tag,
+          collection: matched_scene.dig("studio", "name"),
+          title: matched_scene["title"],
+          date_released: Time.strptime(matched_scene["date"], "%Y-%m-%d")
+        )
+      end
+
+      # @param [Hash] scene
+      # @return [Array[String]]
+      def female_actors(scene)
+        actors(scene)
+          .select { |x| x["gender"] == "FEMALE" }
+          .map {  |x| x["name"] }
+      end
+
+      # @param [Hash] scene
+      # @return [Array[String]]
+      def male_actors(scene)
+        actors(scene)
+          .select { |x| x["gender"] == "MALE" }
+          .map {  |x| x["name"] }
+      end
+
+      # Return an Array of Array[Actor]. The first element of the array main actor name and the others are aliases
+      # @param [Hash] scene
+      # @return [Array[Array[String]]]
+      def female_actors_arr(scene)
+        actors(scene)
+          .select { |x| x["gender"] == "FEMALE" }
+          .map {  |x| [x["name"]] + x["aliases"] }
+      end
+
+      # Return an Array of Array[Actor]. The first element of the array main actor name and the others are aliases
+      # @param [Hash] scene
+      # @return [Array[Array[String]]]
+      def male_actors_hash(scene)
+        actors(scene)
+          .select { |x| x["gender"] == "FEMALE" }
+          .map {  |x| [x["name"]] + x["aliases"] }
+      end
+
+      # @param [Hash] scene
+      # @return [Hash]
+      def actors(scene)
+        scene["performers"]
+          .map { |x| x["performer"] }
+          .map { |x| x.slice("name", "gender", "aliases") }
+      end
+
+      # @param [Hash] scene
+      # @param [Array[String]] female_actors
+      def female_actors_included?(scene, female_actors)
+        female_actors_search = female_actors_arr(scene).flatten.map(&:normalize).to_set
+        rej = female_actors.reject do |actor|
+          female_actors_search.member? actor.normalize
+        end
+        rej.empty?
+      end
+
+      # @return [Hash{Symbol->Unknown}]
+      # @param [String] term
+      # @param [Integer] limit
+      def grapql_body(term, limit)
+        {
+          operationName: "SearchAll",
+          variables:
+            { limit: limit,
+              term: term },
+          query: <<~GRAPHQL
+            query SearchAll($term: String!, $limit: Int = 5) {
+              searchScene(term: $term, limit: $limit) {
+                id
+                date
+                title
+                studio {
+                  name
+                }
+                performers {
+                  as
+                  performer {
+                    id
+                    name
+                    gender
+                    aliases
+                  }
+                }
+              }
+            }
+          GRAPHQL
+        }.to_json
+      end
+
+      def actor_search_query(actor)
+        {
+          operationName: "SearchPerformers",
+          variables: { term: actor },
+          query: <<~GRAPHQL
+            query SearchPerformers($term: String!, $limit: Int = 5) {
+              searchPerformer(term: $term, limit: $limit) {
+              name
+              gender
+              }
+            }
+          GRAPHQL
+        }.to_json
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/tushy.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/vixen_media"
+
+module XxxRename
+  module SiteClients
+    class Tushy < VixenMedia
+      base_uri "https://www.tushy.com"
+      site_client_name :tushy
+    end
+  end
+end

data/lib/xxx_rename/site_clients/tushy_raw.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/vixen_media"
+
+module XxxRename
+  module SiteClients
+    class TushyRaw < VixenMedia
+      base_uri "https://www.tushyraw.com"
+      site_client_name :tushy_raw
+    end
+  end
+end

data/lib/xxx_rename/site_clients/twistys.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/mg_premium"
+
+module XxxRename
+  module SiteClients
+    class Twistys < MGPremium
+      site_client_name :twistys
+
+      def initialize(config)
+        super(config, site_url: "https://www.twistys.com")
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/vixen.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/vixen_media"
+
+module XxxRename
+  module SiteClients
+    class Vixen < VixenMedia
+      base_uri "https://www.vixen.com"
+      site_client_name :vixen
+    end
+  end
+end

data/lib/xxx_rename/site_clients/vixen_media.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/vixen"
+
+module XxxRename
+  module SiteClients
+    class VixenMedia < Base
+      include HTTParty
+      include Utils
+
+      headers "content-type" => "application/json"
+
+      GRAPHQL_ENDPOINT = "/graphql"
+
+      def search(filename)
+        match = SiteClients::QueryGenerator::Vixen.generate(filename, source_format)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) if match.nil?
+
+        if match.id && match.collection
+          get_video_by_id(match.id, match.collection)
+        elsif match.title && match.actors
+          get_video_by_metadata(match.title, match.actors)
+        end
+      end
+
+      private
+
+      def get_video_by_id(video_id, site)
+        api_resp = self.class.post(GRAPHQL_ENDPOINT, body: body(video_id, site))
+        resp = handle_response! { api_resp }
+
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, "#{site}-#{video_id}") if resp.dig("data", "findOneVideo").nil?
+
+        Data::SceneData.new(
+          {
+            collection: site,
+            collection_tag: site_config.collection_tag,
+            title: resp.dig("data", "findOneVideo", "title"),
+            id: resp.dig("data", "findOneVideo", "videoId").to_s,
+            date_released: Time.parse(resp.dig("data", "findOneVideo", "releaseDate"))
+          }.merge(actors_hash(resp.dig("data", "findOneVideo", "modelsSlugged").map { |m| m["name"] }))
+        )
+      end
+
+      def get_video_by_metadata(title, actors)
+        req_body = search_results_body("#{title} #{actors.join(", ")}")
+        api_resp = handle_response! { self.class.post(GRAPHQL_ENDPOINT, body: req_body) }
+
+        search_results = api_resp.dig("data", "searchVideos", "edges")
+        search_results.map do |search_result_node|
+          search_result = search_result_node["node"]
+          next if search_result.nil? || !scene_match?(search_result, title, actors)
+
+          return Data::SceneData.new(
+            {
+              collection: site,
+              collection_tag: site_config.collection_tag,
+              title: search_result["title"],
+              id: search_result["videoId"].to_s,
+              date_released: Time.parse(search_result["releaseDate"])
+            }.merge(actors_hash(search_result["modelsSlugged"].map { |m| m["name"] }))
+          )
+        end
+      end
+
+      def scene_match?(search_result, title, actors)
+        actors_n = actors.map(&:normalize).to_set
+        res_actors_n = search_result["modelsSlugged"].map { |x| x["name"].normalize }.to_set
+        match?(search_result["title"], title) && actors_n.subset?(res_actors_n)
+      end
+
+      # Generate the POST body
+      #
+      # @return [JSON]
+      def body(video_id, site)
+        {
+          "operationName": "getVideo",
+          "variables": {
+            "videoId": video_id,
+            "site": site
+          },
+          "query": <<~GRAPHQL
+            query getVideo($videoId: ID, $site: Site) {
+              findOneVideo(input: { videoId: $videoId, site: $site }) {
+                id: uuid
+                videoId
+                title
+                releaseDate
+                modelsSlugged: models {
+                  name
+                }
+              }
+            }
+          GRAPHQL
+        }.to_json
+      end
+
+      def search_results_body(query)
+        {
+          "operationName": "getSearchResults",
+          "variables": {
+            "query": query,
+            "site": site,
+            "first": 5
+          },
+          "query": <<~GRAPHQL
+            query getSearchResults($query: String!, $site: Site!, $first: Int) {
+              searchVideos(input: { query: $query, site: $site, first: $first }) {
+                edges {
+                  node {
+                    videoId
+                    title
+                    releaseDate
+                    modelsSlugged: models {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          GRAPHQL
+        }.to_json
+      end
+
+      def site
+        self.class.site_client_name.to_s.upcase.gsub("_", "")
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/whale.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+require "xxx_rename/site_clients/query_generator/whale"
+
+module XxxRename
+  module SiteClients
+    class Whale < Base
+      include HTTParty
+
+      URL_MAPPER = {
+        nannyspy: "https://nannyspy.com",
+        spyfam: "https://spyfam.com",
+        holed: "https://holed.com",
+        lubed: "https://lubed.com",
+        myveryfirsttime: "https://myveryfirsttime.com",
+        tiny4k: "https://tiny4k.com",
+        povd: "https://povd.com",
+        fantasyhd: "https://fantasyhd.com",
+        castingcouchx: "https://castingcouch-x.com",
+        puremature: "https://puremature.com",
+        passionhd: "https://passion-hd.com",
+        exotic4k: "https://exotic4k.com"
+      }.freeze
+
+      site_client_name :whale_media
+
+      # @param [String] filename
+      # @return [Hash, NilClass]
+      def search(filename)
+        match = SiteClients::QueryGenerator::Whale.generate(filename, source_format)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) if match.nil?
+
+        unless URL_MAPPER.key?(match[:collection])
+          raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_CUSTOM,
+                                         "Unknown site collection #{match[:collection]}")
+        end
+
+        url = make_url(match)
+        fetch_details_from_html(url)
+      end
+
+      private
+
+      # @param [String] url
+      # @return [Hash, NilClass]
+      def fetch_details_from_html(url)
+        XxxRename.logger.debug "Scraping data from #{url.to_s.colorize(:blue)}"
+        web_resp = HTTParty.get(url, follow_redirects: false)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, url) unless web_resp.code == 200
+
+        search_string = url.split("/").last
+        parse_scene_details(web_resp.body, search_string)
+      end
+
+      # @param [Nokogiri::HTML::Document] body
+      # @param [String] search_string
+      # @return [Hash, NilClass]
+      def parse_scene_details(body, search_string)
+        doc = Nokogiri::HTML(body)
+        normalised_title = title(doc).downcase.gsub("-", "").gsub(/['"“”‘’„]/, "-").gsub(/[^\s\w-]/, "").gsub(/\s{2,}/, " ").gsub(
+          /\s/, "-"
+        )
+        Data::SceneData.new(
+          female_actors: female_actors(doc),
+          male_actors: [],
+          actors: female_actors(doc),
+          collection: collection(doc),
+          collection_tag: site_config.collection_tag,
+          title: title(doc),
+          id: search_string.gsub(normalised_title, ""), # TODO: This doesn't work some times
+          date_released: nil
+        )
+      end
+
+      # @param [Nokogiri::XML::NodeSet] doc
+      # @return [String]
+      def title(doc)
+        doc.css(".t2019-stitle").text.strip
+      end
+
+      # @param [Nokogiri::XML::NodeSet] doc
+      # @return [Array[String]]
+      def female_actors(doc)
+        doc.css("#t2019-models").css(".badge").map { |x| x.text.strip }.sort
+      end
+
+      # @param [Nokogiri::XML::NodeSet] doc
+      # @return [String]
+      def collection(doc)
+        doc.css("#navigation").css(".my-0").css("a").map { |x| x["alt"] }.first
+      end
+
+      # @param [XxxRename::SiteClients::QueryGenerator::Base::SearchParameters] match
+      # @return [String]
+      def make_url(match)
+        File.join(
+          URL_MAPPER[match[:collection]],
+          "video",
+          match[:title] + match[:id].to_s
+        )
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/wicked.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/algolia_v2"
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    class Wicked < AlgoliaV2
+      SCENES_INDEX_NAME = "all_scenes"
+      MOVIES_INDEX_NAME = "all_movies"
+      ACTORS_INDEX_NAME = "all_actors"
+
+      CDN_BASE_URL = "https://transform.gammacdn.com"
+
+      site_client_name :wicked
+
+      def initialize(config)
+        @site_url = "https://www.wicked.com"
+        super(config)
+      end
+
+      def search(filename)
+        match = QueryGenerator::Base.generic_generate(filename, source_format)
+        title = match&.title.presence || filename.split("_").first&.titleize_custom
+
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) unless title.presence
+
+        resp = fetch_scenes_from_api(title)
+        find_matched_scene!(resp, title)
+      end
+
+      def actor_details(actor)
+        response = fetch_actor_from_api(actor)
+        response&.select { |x| match? actor, x[:name] }
+          &.first
+          &.slice(:name, :gender)
+          &.transform_keys(&:to_s) # Backwards compatibility. Keys should be strings.
+      end
+
+      private
+
+      def find_matched_scene!(search_results, title)
+        scenes = search_results.reject { |x| x[:release_date].nil? }
+                               .select { |x| match?(x[:title], title) }
+
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, title) if scenes.length != 1
+
+        make_scene_data(scenes.first)
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/x_empire.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/algolia_v2"
+require "xxx_rename/site_clients/query_generator/evil_angel"
+
+module XxxRename
+  module SiteClients
+    class XEmpire < AlgoliaV2
+      SCENES_INDEX_NAME = "all_scenes"
+      MOVIES_INDEX_NAME = "all_movies"
+      ACTORS_INDEX_NAME = "all_actors"
+
+      CDN_BASE_URL = "https://transform.gammacdn.com"
+
+      site_client_name :x_empire
+
+      def initialize(config)
+        @site_url = "https://www.hardx.com"
+        super(config)
+      end
+
+      def search(filename)
+        match = SiteClients::QueryGenerator::EvilAngel.generate(filename, source_format)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) if match.nil?
+
+        if match.processed
+          processed_scene_details(match)
+        else
+          unprocessed_scene_details(match)
+        end
+      end
+
+      private
+
+      def processed_scene_details(match)
+        resp = fetch_scenes_from_api(match.title)
+
+        find_matched_scene!(resp, match)
+      end
+
+      def unprocessed_scene_details(match)
+        combined = [
+          fetch_scenes_from_api(match.title),
+          fetch_scenes_from_api("#{match.title} Scene #{match.index}")
+        ].reduce([], :concat)
+
+        find_matched_scene!(combined, match)
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/zero_tolerance.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/algolia_v2"
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    class ZeroTolerance < AlgoliaV2
+      SCENES_INDEX_NAME = "all_scenes"
+      MOVIES_INDEX_NAME = "all_movies"
+
+      site_client_name :zero_tolerance
+
+      CDN_BASE_URL = "https://transform.gammacdn.com"
+
+      def initialize(config)
+        @site_url = "https://www.zerotolerancefilms.com"
+        super(config)
+      end
+
+      def search(filename)
+        match = SiteClients::QueryGenerator::Base.generic_generate(filename, source_format)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) unless match&.title&.presence
+
+        search_results = search_scene_using_title(match.title)
+        find_matched_scene!(search_results, match)
+      end
+
+      private
+
+      def search_scene_using_title(title)
+        with_retry { scenes_index.search(title, default_query)&.[](:hits) }
+      end
+    end
+  end
+end