football-butler 1.1.1 → 2.0.0

data/lib/football/butler/areas.rb

@@ -1,35 +1,26 @@
 # frozen_string_literal: true
+require 'football/butler/apifootball/countries'
+require 'football/butler/football_data/areas'
 
 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
-
-      ## AREAS
-      # v2/areas
-      def self.all(result: PATH)
-        Api.get(path: PATH, result: result)
-      end
+      class << self
+        ## AREA / COUNTRY
+        def by_id(id:)
+          api_switch_method(__method__, { id: id })
+        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
+        ## AREAS / COUNTRIES
+        def all(result: api_switch_result)
+          api_switch_method(__method__, { result: result })
+        end
 
-        by_id(id: area['id'])
+        ## ADDITIONAL
+        def by_name(name:)
+          api_switch_method(__method__, { name: name })
+        end
       end
     end
   end

data/lib/football/butler/base.rb

@@ -3,30 +3,19 @@
 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_REACHED_LIMIT   = 'You reached your request limit.' # code: 429
+      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)
+          return false if !response.is_a?(Hash) &&
+            (response.respond_to?(:parsed_response) &&
+              !response.parsed_response.is_a?(Hash))
           response.dig('message') ? response['message'].start_with?(MSG_REACHED_LIMIT) : false
         end
 
-        # CODES
-        def bad_request?(response)
-          response.dig('errorCode') ? response['errorCode'] == 400 : false
-        end
-
         # RESULT MESSAGES
         def not_found_result(*params)
           error_message("#{params.join(', ')} could not be found.")
@@ -36,9 +25,50 @@ 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/competitions.rb

@@ -1,62 +1,49 @@
 # frozen_string_literal: true
+require 'football/butler/apifootball/competitions'
+require 'football/butler/football_data/competitions'
 
 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:)
+          api_switch_method(__method__, { id: id })
+        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
+        ## COMPETITIONS
+        def all(result: api_switch_result, filters: {})
+          api_switch_method(__method__, { result: result, filters: filters })
+        end
 
-      ## ADDITIONAL
-      # v2/competitions/{id}
-      def self.current_match_day(id:)
-        response = by_id(id:id)
+        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
 
-        if response.is_a?(Hash) && response.dig('message')
-          response
-        else
-          response['currentSeason']['currentMatchday']
+        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
-      end
 
-      # v2/competitions/{id}
-      def self.seasons(id:)
-        response = by_id(id:id)
+        ## ADDITIONAL
+        def current_match_day(id:)
+          api_switch_method(__method__, { id: id })
+        end
 
-        if response.is_a?(Hash) && response.dig('message')
-          response
-        else
-          response['seasons']
+        def seasons(id:)
+          api_switch_method(__method__, { id: id })
         end
       end
+
     end
   end
 end

data/lib/football/butler/configuration.rb

@@ -3,11 +3,20 @@
 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_VERSION_FOOTBALL_DATA = 2
+      API_VERSION_APIFOOTBALL   = 2
+
       # API
-      DEFAULT_API_URL       = "https://api.football-data.org"
+      AVAILABLE_APIS        = [:football_data_org, :apifootball_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
@@ -15,43 +24,61 @@ module Football
       DEFAULT_WAIT_ON_LIMIT = false
 
       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
 
         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)
 
           @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
         )
 
           reset unless @init_done
 
+          @api_name       = set_api_name(api_name) unless api_name.nil?
           @api_token      = api_token unless api_token.nil?
+
           unless api_version.nil?
             @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
+
+          if api_endpoint.nil?
+            @api_endpoint = set_api_endpoint(@api_name, @api_version) if api_name
+          else
+            @api_endpoint = api_endpoint
           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?
+          @wait_on_limit  = set_wait_on_limit(wait_on_limit, @api_name) unless wait_on_limit.nil?
 
-          true
+          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
@@ -66,6 +93,134 @@ 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'
+          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}"
+          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
+          end
+        end
+
+        def http_party_headers
+          case api_name
+          when :apifootball_com
+            {}
+          when :football_data_org
+            { "X-Auth-Token": Configuration.api_token }
+          end
+        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}"
+          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)
+          end
+        end
+
+        def response_apifootball_com(response, result)
+          case result
+          when :default
+            response
+          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 tier_from_response(response)
+          case api_name
+          when :apifootball_com
+            # n/a
+          when :football_data_org
+            Tier.set_from_response_headers(response)
+          end
+        end
+
+        def api_result(klass)
+          case api_name
+          when :apifootball_com
+            :parsed_response
+          when :football_data_org
+            klass::PATH
+          end
+        rescue
+          return nil
+        end
+
+        def class_converter(klass)
+          case api_name
+          when :apifootball_com
+            case klass
+            when 'Areas'
+              return 'Countries'
+            when 'Matches'
+              return 'Events'
+            when 'Scorers'
+              return 'TopScorers'
+            end
+          when :football_data_org
+            case klass
+            when 'Countries'
+              return 'Areas'
+            when 'Events'
+              return 'Matches'
+            when 'TopScorers'
+              return 'Scorers'
+            end
+          end
+
+          klass
+        end
       end
     end
   end