football-butler 1.1.0 → 2.1.1

data/lib/football/butler/areas.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
+require 'football/butler/apifootball/countries'
+require 'football/butler/football_data/areas'
+require 'football/butler/api_football/countries'
 
 module Football
   module Butler
     class Areas < Base
-      PATH = :areas
 
-      ## AREA
-      # v2/areas/{id}
-      # returns area object directly as a hash
-      def self.by_id(id:)
-        path = "#{PATH}/#{id}"
-        Api.get(path: path)
-      end
+      class << self
+        ## AREA / COUNTRY
+        def by_id(id:)
+          api_switch_method(__method__, { id: id })
+        end
 
-      ## AREAS
-      # v2/areas
-      def self.all(result: PATH)
-        Api.get(path: PATH, result: result)
-      end
+        ## AREAS / COUNTRIES
+        def all(result: api_switch_result)
+          api_switch_method(__method__, { result: result })
+        end
+
+        ## ADDITIONAL
+        def by_name(name:, result: api_switch_result, filters: {})
+          api_switch_method(__method__, { name: name, result: result, filters: filters })
+        end
 
-      ## ADDITIONAL
-      # v2/areas
-      # v2/areas/{id}
-      # returns area object directly as a hash
-      def self.by_name(name:)
-        areas = all
-        return areas if areas.is_a?(Hash) && areas.with_indifferent_access.dig('message')
-        area  = areas&.detect { |area| area['name'] == name }
-        return not_found_result(name) unless area
+        def by_code(code:, result: api_switch_result, filters: {})
+          api_switch_method(__method__, { code: code, result: result, filters: filters })
+        end
 
-        by_id(id: area['id'])
+        def search_by_name(name:, result: api_switch_result, filters: {})
+          api_switch_method(__method__, { name: name, result: result, filters: filters })
+        end
       end
     end
   end

data/lib/football/butler/base.rb

@@ -3,28 +3,13 @@
 module Football
   module Butler
     class Base
-      MSG_INVALID_TOKEN   = 'Your API token is invalid.' # 400
-      MSG_NOT_EXIST       = 'The resource you are looking for does not exist' # 404
-      MSG_REACHED_LIMIT   = 'You reached your request limit.' # 429
-      MSG_INVALID_CONFIG  = 'Invalid Configuration, check empty api_token / api_endpoint!'
+      MSG_INVALID_CONFIG  = 'Invalid Configuration, check empty api_token or empty / invalid api_endpoint!'
 
       class << self
-        # MESSAGES
-        def invalid_token?(response)
-          response.dig('message') ? response['message'] == MSG_INVALID_TOKEN : false
-        end
-
-        def resource_not_found?(response)
-          response.dig('message') ? response['message'] == MSG_NOT_EXIST : false
-        end
 
+        # MESSAGES
         def reached_limit?(response)
-          response.dig('message') ? response['message'].start_with?(MSG_REACHED_LIMIT) : false
-        end
-
-        # CODES
-        def bad_request?(response)
-          response.dig('errorCode') ? response['errorCode'] == 400 : false
+          Configuration.reached_limit?(response)
         end
 
         # RESULT MESSAGES
@@ -36,9 +21,51 @@ module Football
           error_message(MSG_INVALID_CONFIG)
         end
 
+        def unsupported_api_call(klass, method)
+          message  = "Method '#{method}' is not supported for the endpoint '#{klass}' by this API: "
+          message += "#{Configuration.api_name}"
+          error_message(message)
+        end
+
+        def unsupported_api_endpoint(klass)
+          error_message("The Endpoint '#{klass}' is not supported by this API: #{Configuration.api_name}")
+        end
+
         def error_message(error)
           { message: error }.with_indifferent_access
         end
+
+        # MULTI-API
+        def api_switch_method(method, named_params)
+          klass = api_switch
+
+          if klass
+            klass.respond_to?(method) ?
+              klass.send(method, **named_params) :
+              unsupported_api_call(this_class, method)
+          else
+            unsupported_api_endpoint(this_class)
+          end
+        end
+
+        def api_switch_result
+          Configuration.api_result(api_switch)
+        end
+
+        def api_switch
+          "Football::Butler::#{api_class}::#{this_class}".constantize
+        rescue
+          return nil
+        end
+
+        def api_class
+          Configuration.api_class
+        end
+
+        def this_class
+          klass = self.to_s.split('::').last
+          Configuration.class_converter(klass)
+        end
       end
     end
   end

data/lib/football/butler/coachs.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'football/butler/api_football/coachs'
+
+module Football
+  module Butler
+    class Coachs < Base
+
+      class << self
+        ## COACHS
+        #
+        def by_id(id:, result: api_switch_result, filters: {})
+          api_switch_method(__method__, { id: id, result: result, filters: filters })
+        end
+
+        def search_by_name(name:, result: api_switch_result, filters: {})
+          api_switch_method(__method__, { name: name, result: result, filters: filters })
+        end
+
+        def by_team(team:, result: api_switch_result, filters: {})
+          api_switch_method(__method__, { team: team, result: result, filters: filters })
+        end
+
+      end
+    end
+  end
+end

data/lib/football/butler/competitions.rb

@@ -1,62 +1,71 @@
 # frozen_string_literal: true
+require 'football/butler/apifootball/competitions'
+require 'football/butler/football_data/competitions'
+require 'football/butler/api_football/leagues'
 
 module Football
   module Butler
     class Competitions < Base
-      PATH = :competitions
-
-      ## COMPETITION
-      # v2/competitions/{id}
-      # returns competition object directly as a hash
-      def self.by_id(id:)
-        path = "#{PATH}/#{id}"
-        Api.get(path: path)
-      end
 
-      ## COMPETITIONS
-      #
-      # areas={AREAS}
-      # plan={PLAN}
-      #
-      # v2/competitions
-      def self.all(result: PATH, filters: Configuration.tier_plan_filter)
-        Api.get(path: PATH, result: result, filters: filters)
-      end
+      class << self
+        ## COMPETITION
+        def by_id(id:)
+          api_switch_method(__method__, { id: id })
+        end
 
-      # v2/competitions?plan={plan}
-      def self.by_plan(plan:, result: PATH, filters: {})
-        filters.merge!({ plan: plan })
-        Api.get(path: PATH, result: result, filters: filters)
-      end
+        def by_country(id:, result: api_switch_result)
+          api_switch_method(__method__, { id: id, result: result })
+        end
 
-      # v2/competitions?areas={id1, id2, ...}
-      def self.by_areas(ids:, result: PATH, filters: {})
-        filters.merge!({ areas: ids.join(',') })
-        Api.get(path: PATH, result: result, filters: filters)
-      end
+        def by_country_name(name:, result: api_switch_result)
+          api_switch_method(__method__, { name: name, result: result })
+        end
 
-      ## ADDITIONAL
-      # v2/competitions/{id}
-      def self.current_match_day(id:)
-        response = by_id(id:id)
+        ## COMPETITIONS
+        def all(result: api_switch_result, filters: {})
+          api_switch_method(__method__, { result: result, filters: filters })
+        end
 
-        if response.is_a?(Hash) && response.dig('message')
-          response
-        else
-          response['currentSeason']['currentMatchday']
+        def all_tier_plan_filter(result: api_switch_result, filters: {})
+          filters.merge!(Configuration.tier_plan_filter)
+          api_switch_method(__method__, { result: result, filters: filters })
         end
-      end
 
-      # v2/competitions/{id}
-      def self.seasons(id:)
-        response = by_id(id:id)
+        def by_plan(plan:, result: api_switch_result, filters: {})
+          api_switch_method(__method__, { plan: plan, result: result, filters: filters })
+        end
+
+        def by_areas(ids:, result: api_switch_result, filters: {})
+          api_switch_method(__method__, { ids: ids, result: result, filters: filters })
+        end
 
-        if response.is_a?(Hash) && response.dig('message')
-          response
-        else
-          response['seasons']
+        ## ADDITIONAL
+        def current_match_day(id:)
+          api_switch_method(__method__, { id: id })
+        end
+
+        def seasons(id:)
+          api_switch_method(__method__, { id: id })
+        end
+
+        def all_seasons(result: api_switch_result)
+          api_switch_method(__method__, { result: result })
+        end
+
+        def search_by_name(name:, result: api_switch_result, filters: {})
+          api_switch_method(__method__, { name: name, result: result, filters: filters })
+        end
+
+        def all_leagues(result: api_switch_result, filters: {})
+          api_switch_method(__method__, { result: result, filters: filters })
+        end
+
+        # /leagues?type=cup
+        def all_cups(result: api_switch_result, filters: {})
+          api_switch_method(__method__, { result: result, filters: filters })
         end
       end
+
     end
   end
 end

data/lib/football/butler/configuration.rb

@@ -3,60 +3,104 @@
 module Football
   module Butler
     module Configuration
+      # MULTI-API
+      API_URL_FOOTBALL_DATA   = 'https://api.football-data.org'
+      API_URL_APIFOOTBALL     = 'https://apiv2.apifootball.com/?'
+      API_URL_API_FOOTBALL    = 'https://v3.football.api-sports.io'
+
+      API_VERSION_FOOTBALL_DATA = 2
+      API_VERSION_APIFOOTBALL   = 2
+      API_VERSION_API_FOOTBALL  = 3
+
       # API
-      DEFAULT_API_URL       = "https://api.football-data.org"
+      AVAILABLE_APIS        = [:football_data_org, :apifootball_com, :api_football_com]
+      DEFAULT_API_NAME      = :football_data_org
+      DEFAULT_API_URL       = API_URL_FOOTBALL_DATA
 
       DEFAULT_API_TOKEN     = nil
-      DEFAULT_API_VERSION   = 2
+      DEFAULT_API_VERSION   = API_VERSION_FOOTBALL_DATA
       DEFAULT_API_ENDPOINT  = "#{DEFAULT_API_URL}/v#{DEFAULT_API_VERSION}"
       
       # ADDITIONAL
       DEFAULT_TIER_PLAN     = nil
       DEFAULT_WAIT_ON_LIMIT = false
 
+      # MESSAGES
+      MSG_REACHED_LIMIT = {
+        football_data_org: 'You reached your request limit.', # code: 429
+        api_football_com: 'Too many requests. Your rate limit is 10 requests per minute.' # code: 200
+      }
+
       class << self
-        attr_accessor :api_version, :api_token, :api_endpoint, :tier_plan, :wait_on_limit, :init_done
+        attr_accessor :api_version, :api_token, :api_endpoint, :tier_plan, :wait_on_limit, :init_done,
+                      :api_name, :header_token_name, :header_additional
 
         def configure
           raise "You need to configure football-butler first, see readme." unless block_given?
 
           yield self
 
+          # api_name: AVAILABLE_APIS
+          @api_name       = set_api_name(self.api_name)
+
           @api_token      ||= DEFAULT_API_TOKEN
           @api_version    ||= DEFAULT_API_VERSION
-          @api_endpoint   ||= DEFAULT_API_ENDPOINT
+          @api_endpoint   ||= set_api_endpoint(@api_name, @api_version)
           @tier_plan      ||= DEFAULT_TIER_PLAN
-          @wait_on_limit  ||= DEFAULT_WAIT_ON_LIMIT
+          @wait_on_limit  ||= set_wait_on_limit(self.wait_on_limit, @api_name)
+
+          @header_token_name ||= set_header_token_name(@api_name)
+          @header_additional ||= {}
 
           @init_done = true
 
-          true
+          api_name_valid?(self.api_name)
         end
 
         def reconfigure(
-          api_token: nil, api_version: nil, api_endpoint: nil, tier_plan: nil, wait_on_limit: nil
+          api_token: nil, api_version: nil, api_endpoint: nil, tier_plan: nil, wait_on_limit: nil,
+          api_name: nil, header_token_name: nil, header_additional: nil
         )
 
           reset unless @init_done
 
-          @api_token      = api_token unless api_token.nil?
-          unless api_version.nil?
+          @api_name       = set_api_name(api_name) unless api_name.nil?
+          @api_token      = api_token if api_token
+
+          if api_version
             @api_version    = api_version
-            @api_endpoint   = "#{DEFAULT_API_URL}/v#{api_version}" if api_endpoint.nil?
+            @api_endpoint   = set_api_endpoint(@api_name, @api_version) if api_endpoint.nil?
           end
-          @api_endpoint   = api_endpoint unless api_endpoint.nil?
-          @tier_plan      = tier_plan unless tier_plan.nil?
-          @wait_on_limit  = wait_on_limit unless wait_on_limit.nil?
 
-          true
+          if api_endpoint.nil?
+            @api_endpoint = set_api_endpoint(@api_name, @api_version) if api_name
+          else
+            @api_endpoint = api_endpoint
+          end
+
+          @tier_plan      = tier_plan if tier_plan
+          @wait_on_limit  = set_wait_on_limit(wait_on_limit, @api_name) unless wait_on_limit.nil?
+
+          @header_token_name = header_token_name ? header_token_name : set_header_token_name(@api_name)
+          @header_additional = header_additional if header_additional
+
+          api_name_valid?(api_name ? api_name : @api_name)
+        end
+
+        def api_name_valid?(api_name)
+          AVAILABLE_APIS.include?(api_name)
         end
 
         def reset
+          @api_name       = DEFAULT_API_NAME
           @api_version    = DEFAULT_API_VERSION
           @api_endpoint   = DEFAULT_API_ENDPOINT
           @tier_plan      = DEFAULT_TIER_PLAN
           @wait_on_limit  = DEFAULT_WAIT_ON_LIMIT
 
+          @header_token_name = set_header_token_name(@api_name)
+          @header_additional = {}
+
           @init_done = true
 
           true
@@ -66,6 +110,223 @@ module Football
         def tier_plan_filter
           tier_plan.nil? ? {} : { plan: tier_plan }
         end
+
+        # [:football_data_org, :apifootball_com]
+        # - https://www.football-data.org/documentation/api
+        # - https://apifootball.com/documentation
+        def api_class
+          case api_name
+          when :apifootball_com
+            'Apifootball'
+          when :football_data_org
+            'FootballData'
+          when :api_football_com
+            'ApiFootball'
+          end
+        end
+
+        def set_api_name(api_name)
+          api_name_valid?(api_name) ? api_name : DEFAULT_API_NAME
+        end
+
+        def set_api_endpoint(api_name, api_version = DEFAULT_API_VERSION)
+          return if api_name.nil?
+
+          case api_name
+          when :apifootball_com
+            API_URL_APIFOOTBALL
+          when :football_data_org
+            "#{API_URL_FOOTBALL_DATA}/v#{api_version}"
+          when :api_football_com
+            API_URL_API_FOOTBALL
+          end
+        end
+
+        def set_wait_on_limit(wait_on_limit, api_name)
+          case api_name
+          when :apifootball_com
+            false
+          when :football_data_org
+            wait_on_limit
+          when :api_football_com
+            wait_on_limit
+          end
+        end
+
+        def set_header_token_name(api_name)
+          case api_name
+          when :apifootball_com
+            # not used in header
+            nil
+          when :football_data_org
+            "X-Auth-Token"
+          when :api_football_com
+            "x-apisports-key"
+          end
+        end
+
+        def http_party_headers
+          result = case api_name
+                   when :apifootball_com
+                    {}
+                   when :football_data_org, :api_football_com
+                     { Configuration.header_token_name => Configuration.api_token }
+                   end
+
+          result.merge!(Configuration.header_additional)
+          result
+        end
+
+        def http_party_url(path)
+          case api_name
+          when :apifootball_com
+            "#{Configuration.api_endpoint}#{path}&APIkey=#{Configuration.api_token}"
+          when :football_data_org
+            "#{Configuration.api_endpoint}/#{path}"
+          when :api_football_com
+            "#{Configuration.api_endpoint}/#{path}"
+          end
+        end
+
+        def http_party_response(response, result)
+          case api_name
+          when :apifootball_com
+            response_apifootball_com(response, result)
+          when :football_data_org
+            response_football_data_org(response, result)
+          when :api_football_com
+            response_api_football_com(response, result)
+          end
+        end
+
+        def response_apifootball_com(response, result)
+          case result
+          when :default
+            response
+          when :array_first
+            response.parsed_response.is_a?(Array) ? response.parsed_response.first : nil
+          else
+            response.parsed_response
+          end
+        end
+
+        def response_football_data_org(response, result)
+          case result
+          when :default
+            response
+          when :parsed_response
+            response.parsed_response
+          else
+            response&.keys&.include?(result.to_s) ? response[result.to_s] : nil
+          end
+        end
+
+        def response_api_football_com(response, result)
+          case result
+          when :default
+            response
+          when :parsed_response
+            response.parsed_response
+          when :array_first
+            response&.keys&.include?('response') && response['response'].is_a?(Array) ?
+              response['response'].first : nil
+          else
+            response&.keys&.include?('response') ? response['response'] : nil
+          end
+        end
+
+        def api_result(klass)
+          case api_name
+          when :apifootball_com
+            :parsed_response
+          when :football_data_org
+            klass::PATH
+          when :api_football_com
+            :response
+          end
+        rescue
+          return nil
+        end
+
+        def tier_from_response(response)
+          case api_name
+          when :apifootball_com
+            # n/a
+          when :football_data_org, :api_football_com
+            Tier.set_from_response_headers(response)
+          end
+        end
+
+        def class_converter(klass)
+          case api_name
+          when :apifootball_com
+            case klass
+            when 'Areas'
+              return 'Countries'
+            when 'Matches'
+              return 'Events'
+            when 'Fixtures'
+              return 'Events'
+            when 'Scorers'
+              return 'TopScorers'
+            when 'Leagues'
+              return 'Competitions'
+            end
+          when :football_data_org
+            case klass
+            when 'Countries'
+              return 'Areas'
+            when 'Events'
+              return 'Matches'
+            when 'Fixtures'
+              return 'Matches'
+            when 'TopScorers'
+              return 'Scorers'
+            when 'Leagues'
+              return 'Competitions'
+            end
+          when :api_football_com
+            case klass
+            when 'Areas'
+              return 'Countries'
+            when 'Competitions'
+              return 'Leagues'
+            when 'Events'
+              return 'Fixtures'
+            when 'Matches'
+              return 'Fixtures'
+            when 'Scorers'
+              return 'TopScorers'
+            end
+          end
+
+          klass
+        end
+
+        def reached_limit?(response)
+          case api_name
+          when :apifootball_com
+            false
+          when :football_data_org
+            return false if !response.is_a?(Hash) &&
+              (response.respond_to?(:parsed_response) &&
+                !response.parsed_response.is_a?(Hash))
+            return response.dig('message') ? response['message'].start_with?(MSG_REACHED_LIMIT[api_name]) : false
+          when :api_football_com
+            if response.is_a?(HTTParty::Response) && response&.headers.present?
+              if response.headers['x-ratelimit-remaining'] == '0' ||
+                response.headers['x-ratelimit-requests-remaining'] == '0'
+                return true
+              end
+            elsif response.is_a?(HTTParty::Response) && response.parsed_response.dig('errors', 'rateLimit').present?
+              return true
+            end
+          end
+
+          false
+        rescue
+          return false
+        end
       end
     end
   end

data/lib/football/butler/countries.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'football/butler/apifootball/countries'
+require 'football/butler/football_data/areas'
+require 'football/butler/api_football/countries'
+
+module Football
+  module Butler
+    class Countries < Areas
+    end
+  end
+end

data/lib/football/butler/events.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'football/butler/apifootball/events'
+require 'football/butler/football_data/matches'
+require 'football/butler/api_football/fixtures'
+
+module Football
+  module Butler
+    class Events < Matches
+    end
+  end
+end 

data/lib/football/butler/fixtures.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'football/butler/apifootball/events'
+require 'football/butler/football_data/matches'
+require 'football/butler/api_football/fixtures'
+
+module Football
+  module Butler
+    class Fixtures < Matches
+    end
+  end
+end