kinopoisk_unofficial_api 1.0.0.1

data/lib/kinopoisk_unofficial_api/client.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  class Client
+    attr_reader :secret_key, :url
+
+    def initialize(secret_key, url: "https://kinopoiskapiunofficial.tech")
+      @secret_key = secret_key
+      @url = url
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: url, headers: { "X-API-KEY" => secret_key }) do |faraday|
+        faraday.adapter KinopoiskUnofficialApi.configuration.adapter
+        faraday.options.timeout = KinopoiskUnofficialApi.configuration.connection_timeout
+        faraday.options.open_timeout = KinopoiskUnofficialApi.configuration.connection_open_timeout
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      return super unless ENDPOINTS.key?(method_name)
+
+      result = call(method_name, *args)
+
+      ENDPOINTS[method_name][:response_type].call(result)
+    end
+
+    def respond_to_missing?(*args)
+      method_name = args[0]
+
+      ENDPOINTS.key?(method_name) || super
+    end
+
+    def call(method_name, raw_params = {})
+      params = build_params(method_name, raw_params)
+      path = build_path(method_name, params)
+      response = connection.get(path, params)
+      raise Exceptions::ResponseError.new(response: response) unless response.status == 200
+
+      JSON.parse(response.body)
+    end
+
+    private
+
+    def build_params(method_name, raw_params)
+      return {} if ENDPOINTS[method_name][:no_params]
+
+      schema_name = method_name.to_s.split("_").map(&:capitalize).join
+
+      schema = KinopoiskUnofficialApi::RequestSchemas.const_get(schema_name)
+
+      schema.call(raw_params).to_params_hash
+    end
+
+    def build_path(method_name, params)
+      endpoint = ENDPOINTS[method_name]
+      version = endpoint[:version]
+      path = endpoint[:path]
+
+      endpoint[:path_params]&.each do |param|
+        path = path.gsub("{#{param}}", params.delete(param))
+      end
+
+      (+"/api/").concat(version, path)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  class Configuration
+    attr_accessor :adapter, :connection_open_timeout, :connection_timeout, :genres, :countries
+
+    def initialize
+      @adapter = Faraday.default_adapter
+      @connection_open_timeout = 20
+      @connection_timeout = 20
+      @genres = JSON.parse(File.read("#{__dir__}/../../data/genres.json"), symbolize_names: true)
+      @countries = JSON.parse(File.read("#{__dir__}/../../data/countries.json"), symbolize_names: true)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/endpoints.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength
+module KinopoiskUnofficialApi
+  ENDPOINTS = {
+    film: {
+      path: "/films/{id}",
+      path_params: %w[id],
+      response_type: Types::Film,
+      version: "v2.2"
+    }.freeze,
+    film_seasons: {
+      path: "/films/{id}/seasons",
+      path_params: %w[id],
+      response_type: Types::SeasonResponse,
+      version: "v2.2"
+    }.freeze,
+    film_facts: {
+      path: "/films/{id}/facts",
+      path_params: %w[id],
+      response_type: Types::FactResponse,
+      version: "v2.2"
+    }.freeze,
+    film_distributions: {
+      path: "/films/{id}/distributions",
+      path_params: %w[id],
+      response_type: Types::DistributionResponse,
+      version: "v2.2"
+    }.freeze,
+    film_box_office: {
+      path: "/films/{id}/box_office",
+      path_params: %w[id],
+      response_type: Types::BoxOfficeResponse,
+      version: "v2.2"
+    }.freeze,
+    film_awards: {
+      path: "/films/{id}/awards",
+      path_params: %w[id],
+      response_type: Types::AwardResponse,
+      version: "v2.2"
+    }.freeze,
+    film_videos: {
+      path: "/films/{id}/videos",
+      path_params: %w[id],
+      response_type: Types::VideoResponse,
+      version: "v2.2"
+    }.freeze,
+    film_similars: {
+      path: "/films/{id}/similars",
+      path_params: %w[id],
+      response_type: Types::RelatedFilmResponse,
+      version: "v2.2"
+    }.freeze,
+    film_images: {
+      path: "/films/{id}/images",
+      path_params: %w[id],
+      response_type: Types::ImageResponse,
+      version: "v2.2"
+    }.freeze,
+    film_reviews: {
+      path: "/films/{id}/reviews",
+      path_params: %w[id],
+      response_type: Types::ReviewResponse,
+      version: "v2.2"
+    }.freeze,
+    film_external_sources: {
+      path: "/films/{id}/external_sources",
+      path_params: %w[id],
+      response_type: Types::ExternalSourceResponse,
+      version: "v2.2"
+    }.freeze,
+    film_collections: {
+      path: "/films/collections",
+      response_type: Types::FilmCollectionResponse,
+      version: "v2.2"
+    }.freeze,
+    film_premieres: {
+      path: "/films/premieres",
+      response_type: Types::PremiereResponse,
+      version: "v2.2"
+    }.freeze,
+    film_filters: {
+      path: "/films/filters",
+      response_type: Types::FiltersResponse,
+      no_params: true,
+      version: "v2.2"
+    }.freeze,
+    films: {
+      path: "/films",
+      response_type: Types::FilmSearchByFiltersResponse,
+      version: "v2.2"
+    }.freeze,
+    film_sequels_and_prequels: {
+      path: "/films/{id}/sequels_and_prequels",
+      path_params: %w[id],
+      response_type: Types::Array.of(Types::FilmSequelsAndPrequelsResponse),
+      version: "v2.1"
+    }.freeze,
+    search_film_by_keyword: {
+      path: "/films/search-by-keyword",
+      response_type: Types::FilmSearchResponse,
+      version: "v2.1"
+    }.freeze,
+    film_staff: {
+      path: "/staff",
+      response_type: Types::Array.of(Types::StaffResponse),
+      version: "v1"
+    }.freeze,
+    staff: {
+      path: "/staff/{id}",
+      path_params: %w[id],
+      response_type: Types::PersonResponse,
+      version: "v1"
+    }.freeze,
+    persons: {
+      path: "/persons",
+      response_type: Types::PersonByNameResponse,
+      version: "v1"
+    }.freeze,
+    kp_user_votes: {
+      path: "/kp_users/{id}/votes",
+      path_params: %w[id],
+      response_type: Types::KinopoiskUserVoteResponse,
+      version: "v1"
+    }.freeze,
+    api_key: {
+      path: "/api_keys/{apiKey}",
+      path_params: %w[apiKey],
+      response_type: Types::ApiKeyResponse,
+      version: "v1"
+    }.freeze,
+    media_posts: {
+      path: "/media_posts",
+      response_type: Types::MediaPostsResponse,
+      version: "v1"
+    }.freeze
+  }.freeze
+end
+# rubocop:enable Metrics/ModuleLength

data/lib/kinopoisk_unofficial_api/exceptions/base.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module Exceptions
+    class Base < StandardError; end
+  end
+end

data/lib/kinopoisk_unofficial_api/exceptions/response_error.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module Exceptions
+    class ResponseError < Base
+      attr_reader :response
+
+      def initialize(response:)
+        @response = response
+
+        super("Kinopoisk Unofficial API has returned the error. (#{error_data_dump})")
+      end
+
+      def error_code
+        response.status
+      end
+
+      def error_message
+        data[:message] || data["message"]
+      end
+
+      def data
+        @data ||= begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          { error_code: response.status, uri: response.env.url.to_s }
+        end
+      end
+
+      private
+
+      def error_data_dump
+        data.map { |k, v| %(#{k}: #{v.inspect}) }.join(", ")
+      end
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/api_key.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class ApiKey < Base
+      attribute :apiKey, Types::String
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class Base < Dry::Struct
+      transform_keys do |key|
+        words = key.to_s.split("_")
+        words.drop(1).map(&:capitalize!)
+        words.join.to_sym
+      end
+
+      def to_params_hash
+        to_h.transform_keys(&:to_s).transform_values(&:to_s)
+      end
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class Film < Base
+      transform_keys { |k| %i[film_id filmId id].include?(k.to_sym) ? :id : k }
+
+      attribute :id, Types::Integer
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_awards.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmAwards < Film; end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_box_office.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmBoxOffice < Film; end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_collections.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmCollections < Base
+      TYPES = %w[
+        TOP_POPULAR_ALL
+        TOP_POPULAR_MOVIES
+        TOP_250_TV_SHOWS
+        TOP_250_MOVIES
+        VAMPIRE_THEME
+        COMICS_THEME
+        CLOSES_RELEASES
+        FAMILY
+        OSKAR_WINNERS_2021
+        LOVE_THEME
+        ZOMBIE_THEME
+        CATASTROPHE_THEME
+        KIDS_ANIMATION_THEME
+        POPULAR_SERIES
+      ].freeze
+
+      attribute?(:type, Types::String.default(TYPES.first)
+                                     .constrained(included_in: TYPES)
+                                     .constructor { |v| v == Undefined ? v : v.to_s.upcase })
+      attribute? :page, Types::Integer.default(1)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_distributions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmDistributions < Film; end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_external_sources.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmExternalSources < Film
+      attribute? :page, Types::Integer.default(1)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_facts.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmFacts < Film; end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_images.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmImages < Film
+      TYPES = %w[
+        STILL
+        SHOOTING
+        POSTER
+        FAN_ART
+        PROMO
+        CONCEPT
+        WALLPAPER
+        COVER
+        SCREENSHOT
+      ].freeze
+
+      attribute?(:type, Types::String.default(TYPES.first)
+                                     .constrained(included_in: TYPES)
+                                     .constructor { |v| v == Undefined ? v : v.to_s.upcase })
+      attribute? :page, Types::Integer.default(1)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_premieres.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmPremieres < Base
+      attribute :year, Types::Integer
+      attribute(:month, Types::String.constrained(included_in: Date::MONTHNAMES.compact.map(&:upcase))
+                                     .constructor do |value|
+                                       case value
+                                       when ::Integer
+                                         value.between?(1, 12) ? Date::MONTHNAMES[value].upcase : value
+                                       when ::Symbol, ::String
+                                         if Date::MONTHNAMES.include?(value.to_s.capitalize)
+                                           value.to_s.upcase
+                                         elsif Date::ABBR_MONTHNAMES.include?(value.to_s.capitalize)
+                                           month_index = Date::ABBR_MONTHNAMES.index(value.to_s.capitalize)
+                                           Date::MONTHNAMES[month_index].upcase
+                                         end
+                                       else
+                                         value
+                                       end
+                                     end)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_reviews.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmReviews < Film
+      ORDER_TYPES = %w[
+        DATE_ASC
+        DATE_DESC
+        USER_POSITIVE_RATING_ASC
+        USER_POSITIVE_RATING_DESC
+        USER_NEGATIVE_RATING_ASC
+        USER_NEGATIVE_RATING_DESC
+      ].freeze
+
+      attribute? :page, Types::Integer.default(1)
+      attribute?(:order, Types::String.default(ORDER_TYPES.first)
+                                      .constrained(included_in: ORDER_TYPES)
+                                      .constructor { |v| v == Undefined ? v : v.to_s.upcase })
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_seasons.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmSeasons < Film; end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_sequels_and_prequels.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmSequelsAndPrequels < Film; end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_similars.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmSimilars < Film; end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_staff.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmStaff < Base
+      transform_keys { |k| %i[film_id filmId].include?(k.to_sym) ? :filmId : k }
+
+      attribute :filmId, Types::Integer
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/film_videos.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class FilmVideos < Film; end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/films.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class Films < Base
+      GENRES =
+        KinopoiskUnofficialApi.configuration.genres
+                              .reduce({}) { |res, value| res.merge(value[:genre].downcase => value[:id]) }
+                              .delete_if { |k, _| k == "" }
+                              .freeze
+      COUNTRIES =
+        KinopoiskUnofficialApi.configuration.countries
+                              .reduce({}) { |res, value| res.merge(value[:country].downcase => value[:id]) }
+                              .delete_if { |k, _| k == "" }
+                              .freeze
+      ORDER_TYPES = %w[
+        RATING
+        NUM_VOTE
+        YEAR
+      ].freeze
+      TYPES = %w[
+        ALL
+        FILM
+        TV_SHOW
+        TV_SERIES
+        MINI_SERIES
+      ].freeze
+
+      attribute?(:genres, Types::String.constrained(format: /^\d+(,\d+)*$/)
+                                       .constructor do |value|
+                                         case value
+                                         when ::Integer
+                                           value.to_s
+                                         when ::Array
+                                           value.map do |v|
+                                             case v
+                                             when ::String, ::Symbol
+                                               GENRES[v.to_s.downcase] || v
+                                             else
+                                               v
+                                             end
+                                           end.join(",")
+                                         when ::String, ::Symbol
+                                           (GENRES[value.to_s.downcase] || value).to_s
+                                         else
+                                           value
+                                         end
+                                       end)
+      attribute?(:countries, Types::String.constrained(format: /^\d+(,\d+)*$/)
+                                          .constructor do |value|
+                                            case value
+                                            when ::Integer
+                                              value.to_s
+                                            when ::Array
+                                              value.map do |v|
+                                                case v
+                                                when ::String, ::Symbol
+                                                  COUNTRIES[v.to_s.downcase] || v
+                                                else
+                                                  v
+                                                end
+                                              end.join(",")
+                                            when ::String, ::Symbol
+                                              (COUNTRIES[value.to_s.downcase] || value).to_s
+                                            else
+                                              value
+                                            end
+                                          end)
+      attribute?(:order, Types::String.default(ORDER_TYPES.first)
+                                      .constrained(included_in: ORDER_TYPES)
+                                      .constructor { |v| v == Undefined ? v : v.to_s.upcase })
+      attribute?(:type, Types::String.default(TYPES.first)
+                                     .constrained(included_in: TYPES)
+                                     .constructor { |v| v == Undefined ? v : v.to_s.upcase })
+      attribute? :ratingFrom, (Types::Float | Types::Integer).default(0)
+      attribute? :ratingTo, (Types::Float | Types::Integer).default(10)
+      attribute? :yearFrom, Types::Integer.default(1000)
+      attribute? :yearTo, Types::Integer.default(3000)
+      attribute? :imdbId, Types::String
+      attribute? :keyword, Types::String
+      attribute? :page, Types::Integer.default(1)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/kp_user_votes.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class KpUserVotes < Base
+      transform_keys { |k| %i[kp_user_id kpUserId user_id userId id].include?(k.to_sym) ? :id : k }
+
+      attribute :id, Types::Integer
+      attribute? :page, Types::Integer.default(1)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/media_posts.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class MediaPosts < Base
+      attribute? :page, Types::Integer.default(1)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/persons.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class Persons < Base
+      attribute :name, Types::String
+      attribute? :page, Types::Integer.default(1)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/search_film_by_keyword.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class SearchFilmByKeyword < Base
+      attribute(:keyword, Types::String.constructor { |v| v.is_a?(Array) ? v.join(", ") : v })
+      attribute? :page, Types::Integer.default(1)
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas/staff.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    class Staff < Base
+      transform_keys { |k| %i[staff_id staffId person_id personId id].include?(k.to_sym) ? :id : k }
+
+      attribute :id, Types::Integer
+    end
+  end
+end

data/lib/kinopoisk_unofficial_api/request_schemas.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module RequestSchemas
+    include Dry.Types()
+  end
+end

data/lib/kinopoisk_unofficial_api/types/api_key_response/daily_quota.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module KinopoiskUnofficialApi
+  module Types
+    class ApiKeyResponse < Base
+      class DailyQuota < Base
+        attribute :value, Types::Integer
+        attribute :used, Types::Integer
+      end
+    end
+  end
+end