sports-butler 1.0.0

data/lib/sports/butler/configuration.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    class Configuration
+      # Sports
+      AVAILABLE_SPORTS = [:soccer, :basketball]
+
+      # APIs
+      AVAILABLE_APIS = [
+        # Soccer
+        :football_data_org, :apifootball_com, :api_football_com,
+        # Basketball
+        :api_basketball_com
+      ]
+
+      AVAILABLE_SPORT_API = {
+        soccer: [:football_data_org, :apifootball_com, :api_football_com],
+        basketball: [:api_basketball_com]
+      }
+
+      class << self
+
+        attr_accessor :api_token, :api_base_url,
+                      :header_token_name, :header_additional
+
+        def configure
+          raise "You need to configure sports-butler first, see readme." unless block_given?
+
+          yield self
+
+          @api_token  ||= default_api_hash
+          @api_base_url  ||= default_api_hash
+
+          @header_token_name ||= set_header_token_name
+          @header_additional ||= {}
+
+        end
+
+        def default_api_hash
+          { soccer: {}, basketball: {} }
+        end
+
+        def set_header_token_name
+          {
+            soccer: {
+              football_data_org: 'X-Auth-Token',
+              api_football_com: 'x-apisports-key'
+            },
+            basketball: {
+              api_basketball_com: 'x-apisports-key'
+            }
+          }
+        end
+
+        def invalid_config?(sport, api_name)
+          Configuration.api_token[sport][api_name].blank? ||
+            !Configuration.valid_sport_api?(sport, api_name)
+        end
+
+        def http_party_url(path, sport, api_name)
+          case api_name
+          when :apifootball_com
+            "#{Configuration.api_base_url[sport][api_name]}?#{path}&APIkey=#{Configuration.api_token[sport][api_name]}"
+          else
+            "#{Configuration.api_base_url[sport][api_name]}/#{path}"
+          end
+        end
+
+        def http_party_url_suffix(url, sport, api_name)
+          case api_name
+          when :apifootball_com
+            "#{url}&APIkey=#{Configuration.api_token[sport][api_name]}"
+          else
+            "#{url}"
+          end
+        end
+
+        def http_party_headers(sport, api_name)
+          result = case api_name
+
+                   # SOCCER
+                   when :apifootball_com
+                     {}
+                   when :football_data_org, :api_football_com
+                     { Configuration.header_token_name[sport][api_name] => Configuration.api_token[sport][api_name] }
+
+                   # BASKETBALL
+                   when :api_basketball_com
+                     { Configuration.header_token_name[sport][api_name] => Configuration.api_token[sport][api_name] }
+                   end
+
+          result.merge!(Configuration.header_additional)
+          result
+        end
+
+        def valid_sport_api?(sport, api_name)
+          AVAILABLE_SPORT_API[sport]&.any?{|name| name == api_name}
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/endpoints.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module Sports
+  module Butler
+    class Endpoints
+      require 'sports/butler/shared/all_sports'
+      require 'sports/butler/shared/api_coms'
+
+      include Sports::Butler::Shared::AllSports
+      include Sports::Butler::Shared::ApiComs
+
+      attr_accessor :sport, :api_name, :api
+
+      def initialize(sport:, api_name:, api:)
+        @sport    = sport
+        @api_name = api_name
+        @api      = api
+      end
+
+      def build_path(_action)
+        path
+      end
+
+      def error_missing_endpoint_method(meth)
+        "The method '#{meth}' is not available for endpoint '#{self.class.name.demodulize}' in API #{self.api_name}."
+      end
+
+
+      # param names
+      def filters_by_match(id)
+        { id: id }
+      end
+
+      def filters_by_team(team_id)
+        { team: team_id }
+      end
+
+      def filters_by_id(id)
+        { id: id }
+      end
+
+      def filters_by_player(id)
+        { player: id }
+      end
+
+      def filters_by_competition(id)
+        { competition_id: id }
+      end
+
+      def filters_by_competition_and_year(id, year)
+        { league: id, season: year }
+      end
+
+      def filters_search_by_name(name)
+        { name: name }
+      end
+    end
+  end
+end

data/lib/sports/butler/shared/all_sports.rb

@@ -0,0 +1,175 @@
+module Sports
+  module Butler
+    module Shared
+      module AllSports
+
+        def all(filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_name(name: , filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ name: name })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_country_name(country_name: , filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ country: country_name })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_id(id: , filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!(filters_by_id(id))
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_match(match_id: , filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!(filters_by_match(match_id))
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_country(country_id: , filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ country_id: country_id })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_competition(competition_id:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!(filters_by_competition(competition_id))
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def search_by_name(name:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!(filters_search_by_name(name))
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_player(player_id:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!(filters_by_player(player_id))
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_team(team_id:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!(filters_by_team(team_id))
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_coach(coach_id:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ coach: coach_id })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_id_and_season(id:, season:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ id: id, season: season })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_competition_and_year(competition_id:, year:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!(filters_by_competition_and_year(competition_id, year))
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_teams(team_id:, second_team_id:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!(filters_by_teams(team_id, second_team_id))
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_competition_and_season(competition_id:, season:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ league: competition_id, season: season })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_team_and_season(team_id:, season:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ team: team_id, season: season })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_team_and_range(team_id:, from:, to:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ team_id: team_id, from: from, to: to })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_competition_and_range(competition_id:, from:, to:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!(filters_by_competition_and_range(competition_id, from, to))
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_season(season:, filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ season: season })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_code(code: , filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ code: code })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def by_competition_and_team_and_season(competition_id:, team_id:, season: , filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ league: competition_id, team: team_id, season: season })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/shared/api_coms.rb

@@ -0,0 +1,24 @@
+module Sports
+  module Butler
+    module Shared
+      module ApiComs
+
+        def leagues(filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ type: 'league' })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+
+        def cups(filters: {})
+          return error_missing_endpoint_method(__method__) unless available_endpoint_methods.include?(__method__)
+
+          filters.merge!({ type: 'cup' })
+          api.get(path: build_path(path), filters: filters)
+          api
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'sports/butler/base'
+
+module Sports
+  module Butler
+    class Soccer < Sports::Butler::Base
+
+      ENDPOINTS = [
+        :countries,
+        :competitions,
+        :matches,
+        :teams,
+        :players,
+        :head_to_head,
+        :lineups,
+        :odds,
+        :scorers,
+        :standings,
+        :coachs,
+        :injuries,
+        :predictions,
+        :sidelineds,
+        :statistics,
+        :timezones,
+        :transfers,
+        :trophies,
+        :venues
+      ]
+
+      def initialize(sport:, api_name:)
+        super
+      end
+
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/coachs.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Coachs < Sports::Butler::SoccerApi::Coachs
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/competitions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Competitions < Sports::Butler::SoccerApi::Competitions
+          def available_endpoint_methods
+            [:all, :by_id, :search_by_name, :by_country_name, :seasons, :leagues, :cups]
+          end
+
+          def path
+            :leagues
+          end
+
+          def seasons(filters: {})
+            api.get(path: "#{path}/seasons", filters: filters)
+            api
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/countries.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Countries < Sports::Butler::SoccerApi::Countries
+
+          def available_endpoint_methods
+            [:all, :by_name, :search_by_name]
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/head_to_head.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class HeadToHead < Sports::Butler::SoccerApi::HeadToHead
+          def available_endpoint_methods
+            [:by_teams]
+          end
+
+          def path
+            'fixtures/headtohead'
+          end
+
+          def filters_by_teams(team_id, second_team_id)
+            { h2h: "#{team_id}-#{second_team_id}" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/injuries.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Injuries < Sports::Butler::SoccerApi::Injuries
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/lineups.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Lineups < Sports::Butler::SoccerApi::Lineups
+          def path
+            'fixtures/lineups'
+          end
+
+          def filters_by_match(id)
+            { fixture: id }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/matches.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Matches < Sports::Butler::SoccerApi::Matches
+          def available_endpoint_methods
+            [:by_id, :by_competition_and_year, :all]
+          end
+
+          def path
+            :fixtures
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/odds.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Odds < Sports::Butler::SoccerApi::Odds
+          def path
+            :odds
+          end
+
+          def filters_by_match(id)
+           { fixture: id }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/players.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Players < Sports::Butler::SoccerApi::Players
+
+          def available_endpoint_methods
+            [:by_id_and_season]
+          end
+
+          def path
+            :players
+          end
+        end
+      end
+    end
+  end
+end
+1

data/lib/sports/butler/soccer_api/api_football_com/predictions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Predictions < Sports::Butler::SoccerApi::Predictions
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/scorers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Scorers < Sports::Butler::SoccerApi::Scorers
+          def available_endpoint_methods
+            [:by_competition_and_year]
+          end
+
+          def path
+            'players/topscorers'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/sidelineds.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Sidelineds < Sports::Butler::SoccerApi::Sidelineds
+
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/standings.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Standings < Sports::Butler::SoccerApi::Standings
+          def path
+            :standings
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/statistics.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Statistics < Sports::Butler::SoccerApi::Statistics
+          def path
+            'fixtures/statistics'
+          end
+
+          def filters_by_match(id)
+            { fixture: id }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/teams.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Teams < Sports::Butler::SoccerApi::Teams
+          def available_endpoint_methods
+            [:by_id, :by_name]
+          end
+
+          def path
+            :teams
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sports/butler/soccer_api/api_football_com/timezones.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Sports
+  module Butler
+    module SoccerApi
+      module ApiFootballCom
+        class Timezones < Sports::Butler::SoccerApi::Timezones
+
+        end
+      end
+    end
+  end
+end