xxx_rename 0.0.1

data/lib/xxx_rename/site_clients/evil_angel.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/evil_angel"
+require "xxx_rename/site_clients/algolia_v2"
+
+module XxxRename
+  module SiteClients
+    class EvilAngel < 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 :evil_angel
+
+      def initialize(config)
+        @site_url = "https://www.evilangel.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
+
+      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 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/goodporn.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+require "xxx_rename/site_clients/query_generator/goodporn"
+
+module XxxRename
+  module SiteClients
+    class Goodporn < Base
+      include HTTParty
+
+      base_uri "https://goodporn.to"
+      site_client_name :goodporn
+
+      # rubocop:disable Style/RegexpLiteral
+      HEADLINE_REGEX = /
+      (?<collection>[^-]*)                          # Collection
+      \s-\s                                         # Separator
+      (?<scene_title>.*)                            # Scene Title
+      \s-\s                                         # Separator
+      (?<date_released>\d\d\/\d\d\/\d\d\d\d)        # Release Date
+      /x.freeze
+      # rubocop:enable Style/RegexpLiteral
+
+      # rubocop:disable Style/RegexpLiteral
+      BRAZZERS_LIVE_HEADLINE_REGEX = /
+      -\s                                           # Prefix only for Brazzers Live
+      (?<collection>[^-]*)                          # Collection
+      :\s?                                          # Scene Separator
+      (?<scene_title>[^-]*)                         # Scene Title
+      \s-\s                                         # Separator
+      (?<date_released>\d\d\/\d\d\/\d\d\d\d)        # Release Date
+      /x.freeze
+      # rubocop:enable Style/RegexpLiteral
+
+      # @param [String] filename
+      # @return [XxxRename::Data::SceneData]
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def search(filename, **_opts)
+        pattern = pattern(filename) || raise(Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename))
+
+        doc = Nokogiri::HTML request_search_html(pattern.gsub("-", " "))
+        link = search_result_links(doc).select { |url| url.include? pattern }.first
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) if link.nil?
+
+        scene = Nokogiri::HTML request_video_html(link)
+        metadata_tags = scene.css("#tab_video_info").css(".info").children.select { |x| x.children.length > 1 }
+        actors_hash = actors_hash(actors(metadata_tags))
+        match = headline(scene).match(HEADLINE_REGEX) || headline(scene).match(BRAZZERS_LIVE_HEADLINE_REGEX)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, filename) if match.nil? || actors_hash.nil?
+
+        Data::SceneData.new(
+          {
+            collection: match[:collection],
+            collection_tag: "GP",
+            title: match[:scene_title],
+            id: nil,
+            date_released: Time.strptime(match[:date_released], "%m/%d/%Y")
+          }.merge(actors_hash)
+        )
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      private
+
+      # @param [Hash] actors_hash
+      # @return [Array]
+      def female_actors(actors_hash)
+        actors_hash[:female_actors].nil? ? [] : actors_hash[:female_actors]
+      end
+
+      # @param [Hash] actors_hash
+      # @return [Array]
+      def male_actors(actors_hash)
+        actors_hash[:male_actors].nil? ? [] : actors_hash[:male_actors]
+      end
+
+      # @param [String] filename
+      # @return [nil, String]
+      def pattern(filename)
+        SiteClients::QueryGenerator::Goodporn.generate(filename, source_format)
+      end
+
+      def headline(doc)
+        doc.css(".headline").css("h1").text.strip
+      end
+
+      def search_result_links(doc)
+        search_results = doc.css("#list_videos_videos_list_search_result_items").children
+        search_results = search_results.select { |x| x.children.length == 3 }
+        search_results.map { |child| child.children[1]["href"] }
+      end
+
+      def actors(doc)
+        actors = doc.select { |x| x.text.include? "Models" }.first&.children&.css("a")&.map { |x| x.text.strip }
+        XxxRename.logger.debug "Unable to fetch actor data".colorize(:red) if actors.nil?
+        actors
+      end
+
+      def request_search_html(query)
+        self.class.get("/search/#{CGI.escape(query)}").body
+      end
+
+      def request_video_html(link)
+        HTTParty.get(link).body
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/jules_jordan.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/jules_jordan_media"
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    class JulesJordan < JulesJordanMedia
+      base_uri "https://www.julesjordan.com"
+
+      site_client_name :jules_jordan
+
+      COLLECTION = "Jules Jordan"
+
+      def search(filename)
+        refresh_datastore(1) if datastore_refresh_required?
+        match = SiteClients::QueryGenerator::Base.generic_generate(filename, source_format)
+        lookup_in_datastore!(match)
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/jules_jordan_media.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+require "xxx_rename/site_clients/base"
+require "xxx_rename/file_utilities"
+require "xxx_rename/constants"
+
+module XxxRename
+  module SiteClients
+    class JulesJordanMedia < Base
+      include FileUtilities
+      include HTTParty
+
+      headers Constants::DEFAULT_HEADERS
+
+      SCENES_ENDPOINT_TRIAL = "/trial/categories/movies_$page$_d.html"
+
+      def datastore_refresh_required?
+        if config.force_refresh_datastore
+          XxxRename.logger.info "#{"[FORCE REFRESH]".colorize(:green)} #{self.class.name}"
+          true
+        else
+          false
+        end
+      end
+
+      def refresh_datastore(page = 1)
+        return if all_scenes_processed?
+
+        scenes = get_scenes_from_page(page)
+        if scenes.empty?
+          XxxRename.logger.info "#{"[DATASTORE REFRESH COMPLETE]".colorize(:green)} #{self.class.site_client_name}"
+          @all_scenes_processed = true
+          return true
+        end
+
+        scenes.map { |scene_data| site_client_datastore.create!(scene_data, force: true) }
+        refresh_datastore(page + 1)
+      end
+
+      def all_scenes_processed?
+        all_scenes_processed
+      end
+
+      private
+
+      def lookup_in_datastore!(match)
+        msg = "requires both movie title(%collection) and scene title(%title)"
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, msg) if match.nil?
+
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, msg) unless collection_key(match) && match.title.presence
+
+        msg = "collection should be either 'julesjordan' or 'manuelferrara' (case-insensitive, spaces allowed)"
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, msg) unless valid_collection?(collection_key(match))
+
+        index_key = site_client_datastore.generate_lookup_key(collection_key(match), match.title)
+        scene_data_key = site_client_datastore.find_by_key?(index_key)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, index_key) if scene_data_key.nil?
+
+        scene_data = site_client_datastore.find_by_key?(scene_data_key)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, scene_data_key) if scene_data.nil?
+
+        scene_data
+      end
+
+      def collection_key(match)
+        config.override_site.presence || match.collection.presence
+      end
+
+      def valid_collection?(collection)
+        match?(collection, self.class::COLLECTION)
+      end
+
+      def all_scenes_processed
+        @all_scenes_processed ||= false
+      end
+
+      def get_scenes_from_page(page)
+        XxxRename.logger.info "#{"[PROCESSING PAGE]".colorize(:green)} #{page}"
+        url = SCENES_ENDPOINT_TRIAL.gsub("$page$", page.to_s)
+        doc = doc(url)
+
+        all_scenes_urls(doc).map do |link|
+          scene_data = make_scene_data(link)
+          XxxRename.logger.info "#{"[PROCESSING SCENE]".colorize(:green)} #{scene_data.title}"
+          scene_data
+        end
+      end
+
+      def all_scenes_urls(doc)
+        doc.css(".category_listing_wrapper_updates a")
+           .map { |x| x["href"] }
+           .select { |x| x.include?("/trial/scenes/") }
+           .uniq
+      end
+
+      def make_scene_data(link)
+        endpoint = link.gsub(self.class.base_uri, "")
+        doc = doc(endpoint)
+        actors_hash = actors_hash(actors(doc))
+        movie_hash = movie_hash(doc)
+        hash = {}.tap do |h|
+          h[:collection] = self.class::COLLECTION
+          h[:collection_tag] = site_config.collection_tag
+          h[:title] = title(doc)
+          h[:id] = nil
+          h[:date_released] = date_released(doc)
+          h[:movie] = movie_hash unless movie_hash.nil?
+        end.merge(actors_hash)
+        Data::SceneData.new(hash)
+      end
+
+      def title(doc)
+        doc.css(".title_bar_hilite").text.strip
+      end
+
+      def date_released(doc)
+        txt = doc.css(".backgroundcolor_info .update_date").text.strip
+        Time.strptime(txt, "%m/%d/%Y")
+      end
+
+      def female_actors(actors)
+        actors.select { |x| ActorsHelper.instance.female? x }
+      end
+
+      def actors(doc)
+        doc.css(".backgroundcolor_info .update_models a")
+           .map(&:text)
+           .map(&:strip)
+      end
+
+      def movie_hash(doc)
+        movie_url, movie_name = movie_details(doc)
+        return nil if movie_url.nil?
+
+        endpoint = movie_url.gsub(self.class.base_uri, "")
+        if processed_movies.key?(endpoint)
+          XxxRename.logger.debug "[MOVIE ALREADY PROCESSED] #{movie_name}"
+          return processed_movies[endpoint]
+        end
+
+        XxxRename.logger.info "#{"[PROCESSING MOVIE]".colorize(:green)} #{movie_name}"
+        movie_doc = doc(endpoint)
+        h = {
+          name: movie_name,
+          url: movie_url,
+          front_image: movie_doc.at("//div[@class=\"front\"]/a/img/@src0_3x").value,
+          back_image: movie_doc.at("//div[@class=\"back\"]/a/img/@src0_3x").value,
+          studio: self.class::COLLECTION
+        }
+        processed_movies[endpoint] = h
+        h
+      end
+
+      def movie_details(doc)
+        node = doc.css(".backgroundcolor_info .update_dvds a")
+        return [nil, nil] if node.nil?
+
+        url = node.map { |x| x["href"] }.first
+        name = node.map(&:text).map(&:strip)&.first
+        [url, name]
+      end
+
+      def doc(endpoint)
+        res = handle_response!(return_raw: true) { self.class.get(endpoint) }
+        Nokogiri::HTML res.parsed_response
+      end
+
+      def processed_movies
+        @processed_movies ||= {}
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/manuel_ferrara.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/jules_jordan_media"
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    class ManuelFerrara < JulesJordanMedia
+      base_uri "https://manuelferrara.com/"
+
+      site_client_name :manuel_ferrara
+
+      COLLECTION = "Manuel Ferrara"
+
+      SCENES_ENDPOINT_TRIAL = "/trial/categories/movies_$page$_d.html"
+
+      def search(filename)
+        refresh_datastore(1) if datastore_refresh_required?
+        match = SiteClients::QueryGenerator::Base.generic_generate(filename, source_format)
+        lookup_in_datastore!(match)
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/mg_premium.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/mg_premium"
+
+module XxxRename
+  module SiteClients
+    class MGPremium < Base
+      include HTTParty
+      include Utils
+
+      base_uri "https://site-api.project1service.com"
+
+      SEARCH_ENDPOINT = "/v2/releases"
+      ACTOR_ENDPOINT = "/v1/actors"
+
+      # @param [XxxRename::Data::Config] config
+      # @param [String] site_url
+      def initialize(config, site_url:)
+        @site_url = site_url
+        super(config)
+      end
+
+      # @param [String] filename
+      # @return [Hash{Symbol->Array | String | Time}, nil] A Hash containing details extracted from the file.
+      # @param [Hash] opts
+      # @option opts [Boolean] recursive If needed to search for a file recursively
+      def search(filename, **opts)
+        str = search_scene_title(filename)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) if str.nil?
+
+        @normalized_scene_name = str.normalize
+
+        scene_resp = api_search(str)
+        return scene_resp[@normalized_scene_name] unless scene_resp[@normalized_scene_name].nil?
+
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, str) unless opts[:recursive]
+
+        scene_resp = recursive_search(str)
+        scene_resp || raise(Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, str))
+      end
+
+      def actor_details(actor)
+        opts = opt_search_actor(actor)
+        response = self.class.get(ACTOR_ENDPOINT, opts)
+        return unless response.code == 200
+
+        response["result"]&.select { |x| match? actor, x["name"] }&.first&.slice("name", "gender")
+      end
+
+      private
+
+      # @param [String] search_string Search parameter
+      # @return [Hash{Symbol->Array | String | Time}, nil]
+      def recursive_search(search_string)
+        while search_string.length >= 3
+          search_string = reduce_search_string(search_string)
+          XxxRename.logger.debug "Trying with #{search_string.to_s.colorize(:blue)}"
+          scene = api_search(search_string)
+          return scene[@normalized_scene_name] unless scene[@normalized_scene_name].nil?
+        end
+      end
+
+      def api_search(search_string)
+        opts = opt_search_scene(search_string)
+        response = self.class.get(SEARCH_ENDPOINT, opts)
+
+        case response.code
+        when 200
+          parsed_response = JSON.parse(response.body)
+          fetch_scene_details(parsed_response["result"])
+        when 404
+          parsed_response = JSON.parse(response.body)
+          if parsed_response.is_a?(Array) && banned_search?(parsed_response.first["errors"])
+            reduced_search_string = reduce_search_string(search_string)
+            XxxRename.logger.debug "Got banned search error with search string" \
+                  "#{search_string.to_s.colorize(:red)}. Trying with" \
+                  "#{reduced_search_string.to_s.colorize(:red)}\n"
+            api_search(reduced_search_string)
+          else
+            obj = {
+              request_options: opts,
+              response_code: response.code,
+              response_body: response.body
+            }
+            raise Errors::SearchError.new(search_string, obj)
+          end
+        else
+          handle_response! { response }
+        end
+      end
+
+      # @param [String] search_string
+      # @return [String]
+      def reduce_search_string(search_string)
+        # Remove last 5 characters
+        search_string.chop.chop.chop.chop.chop
+      end
+
+      def banned_search?(errors)
+        errors.each do |err|
+          return true if err["code"] == 1750
+        end
+        false
+      end
+
+      def opt_search_actor(actor)
+        {
+          query: {
+            limit: 10,
+            search: actor
+          },
+          headers: {
+            "Instance" => instance_token,
+            "User-Agent" => "Mozilla/5.0 (platform; rv:geckoversion) Gecko/geckotrail Firefox/firefoxversion"
+          },
+          timeout: 5
+        }
+      end
+
+      def opt_search_scene(scene_name)
+        {
+          query: {
+            type: "scene",
+            limit: 10,
+            search: scene_name
+          },
+          headers: {
+            "Instance" => instance_token,
+            "User-Agent" => "Mozilla/5.0 (platform; rv:geckoversion) Gecko/geckotrail Firefox/firefoxversion"
+          },
+          timeout: 5
+        }
+      end
+
+      def instance_token(refresh = false)
+        @instance_token = refresh_token_mg(@site_url) if @instance_token.nil?
+        @instance_token = refresh_token_mg(@site_url) if refresh
+
+        @instance_token
+      end
+
+      def refresh_token_mg(site_url)
+        XxxRename.logger.debug "Refreshing Instance Token...".colorize(:blue)
+        response = HTTParty.get(site_url)
+        case response.code
+        when 429
+          raise "Failed to refresh instance token. Too many requests made..."
+        when 200
+          cookie_header = response.headers["set-cookie"].to_s
+          instance_token_param = cookie_header.split(";").first
+          instance_token_param.sub("instance_token=", "")
+        else
+          raise "Error in refreshing instance token: #{response.code}"
+        end
+      rescue OpenSSL::SSL::SSLError
+        raise "Unable to open connection to #{site_url}. Check your internet connection and try again."
+      end
+
+      def fetch_scene_details(results)
+        resp = {}
+        return resp if results.empty?
+
+        results.each do |scene|
+          normalized_title = title(scene).normalize
+
+          hash = {}.tap do |h|
+            h[:collection] = collection(scene)
+            h[:collection_tag] = site_config.collection_tag
+            h[:title] = title(scene)
+            h[:id] = scene_id(scene)
+            h[:date_released] = date_released(scene)
+            h[:movie] = movie_hash(scene) unless movie_hash(scene).nil?
+            h[:female_actors] = female_actors(scene)
+            h[:male_actors] = male_actors(scene)
+            h[:actors] = female_actors(scene) + male_actors(scene)
+          end
+          resp[normalized_title] = Data::SceneData.new(hash)
+        end
+
+        resp
+      end
+
+      def movie_hash(scene)
+        return nil if scene["parent"].nil?
+
+        parent = scene["parent"]
+        type = parent["type"] == "serie" ? "series" : parent["type"]
+        {
+          name: parent["title"],
+          date: Time.parse(parent["dateReleased"]),
+          url: URI.join(@site_url, "/#{type}/", "#{parent["id"]}/", parent["title"].downcase.gsub(" ", "-")).to_s,
+          front_image: extract_image_url(parent),
+          studio: parent.dig("brandMeta", "displayName"),
+          synopsis: parent["description"]
+        }
+      end
+
+      def extract_image_url(hash)
+        cover_hash = hash.dig("images", "cover", "0") || hash.dig("images", "poster", "0")
+        return if cover_hash.nil?
+
+        res = %w[xx xl lg md sm].find { |x| cover_hash.key?(x) }
+        cover_hash.dig(res, "url") || cover_hash.dig(res, "urls", "default")
+      end
+
+      def female_actors(scene)
+        scene["actors"]
+          .select { |actor| actor["gender"] == "female" }
+          .map { |actor| actor["name"] }
+          .sort
+      end
+
+      def male_actors(scene)
+        scene["actors"]
+          .select { |actor| actor["gender"] == "male" }
+          .map { |actor| actor["name"] }
+          .sort
+      end
+
+      def collection(scene)
+        collections = scene["collections"]
+        return "" if collections.empty?
+
+        collections.first["name"]
+      end
+
+      def title(scene)
+        scene["title"]
+      end
+
+      def scene_id(scene)
+        scene["id"]
+      end
+
+      def date_released(scene)
+        Time.parse(scene["dateReleased"])
+      end
+
+      def search_scene_title(filename)
+        # TODO: Allow client to use section of parameters rather than just the scene title
+        resp = SiteClients::QueryGenerator::MgPremium.generate(filename, source_format)
+
+        resp&.title&.downcase
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/mofos.rb

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