sportradar-api 0.9.12 → 0.11.21

data/lib/sportradar/api/baseball/team.rb

@@ -0,0 +1,147 @@
+module Sportradar
+  module Api
+    module Baseball
+      class Team < Data
+        attr_accessor :response, :id, :market, :name, :alias, :full_name, :venue, :records, :player_stats, :team_stats
+
+        def initialize(data, **opts)
+          @response = data # comment this out when done developing
+          @api      = opts[:api]
+          @id = data['id']
+
+          @games_hash   = {}
+          @players_hash = {}
+          @player_stats = {}
+          @records      = {}
+          @stats        = nil
+          @runs         = nil
+
+          update(data, **opts)
+        end
+
+        def update(data, **opts)
+          handle_names(data)
+          @venue    = Venue.new(data['venue']) if data['venue']
+
+          @alias    = data['abbr']                if data['abbr']
+          @runs     = data['runs'].to_i           if data['runs']
+          # # @home     = data['home'] == 'true'        if data['home']
+          # # @away     = data['away'] == 'true'        if data['away']
+          # # @scoring  = data.dig('scoring', 'quarter') if data.dig('scoring', 'quarter')
+
+          parse_records(data)                               if data['win']
+          parse_players(data.dig('players'), opts[:game])   if data.dig('players')
+
+          if opts[:game]
+            # opts[:game].update_from_team(id, "runs"=>6)
+            # opts[:game].update_from_team(id, "hits"=>11)
+            # opts[:game].update_from_team(id, "errors"=>1)
+            # opts[:game].update_from_team(id, "win"=>11)
+            # opts[:game].update_from_team(id, "loss"=>16)
+            # opts[:game].update_from_team(id, "probable_pitcher"=>{"jersey_number"=>"45", "id"=>"c1f19b5a-9dee-4053-9cad-ee4196f921e1", "win"=>2, "loss"=>3, "era"=>5.0})
+            # opts[:game].update_from_team(id, "starting_pitcher"=>{"last_name"=>"Cotton", "first_name"=>"Jharel", "preferred_name"=>"Jharel", "jersey_number"=>"45"})
+            # opts[:game].update_from_team(id, "current_pitcher"=>{"last_name"=>"Dull", "first_name"=>"Ryan", "preferred_name"=>"Ryan", "jersey_number"=>"66"})
+            # add_game(opts[:game])
+            # opts[:game].update_score(id => @runs)             if @runs
+            opts[:game].update_stats(self, data['statistics'])  if data['statistics']
+          end
+        end
+        def handle_names(data)
+          # need to do some more work here
+          @name = data['name'] if data['name']
+          if data['name'] && data['market']
+            @market = data['market']
+            @full_name = [@market, data['name']].join(' ')
+          elsif data['name'] && !data.key?('market')
+            @full_name = data['name']
+          end
+        end
+
+        def record(type = 'overall')
+          @records[type]
+        end
+
+        def games
+          @games_hash.values
+        end
+        def add_game(game)
+          @games_hash[game.id] = game.id if game
+        end
+
+        def players
+          get_roster if @players_hash.empty?
+          @players_hash.values
+        end
+        alias :roster :players
+
+
+        # parsing response data
+
+        def parse_players(data, game)
+          create_data(@players_hash, data, klass: Player, api: api, team: self, game: game)
+        end
+        def update_player_stats(player, stats, game = nil)
+          game ? game.update_player_stats(player, stats) : @player_stats.merge!(player.id => stats.merge!(player: player))
+        end
+        def parse_records(data)
+          @records['overall'] = Record.new(data, type: 'overall')
+        end
+
+        def parse_season_stats(data)
+          @team_stats = data.dig('statistics')
+          update(data)
+          player_data = data.dig('players')
+          create_data(@players_hash, player_data, klass: Player, api: api, team: self)
+          data
+        end
+
+
+        # data retrieval
+
+        def get_roster
+          data = api.get_data(path_roster)
+          ingest_roster(data)
+        end
+        def ingest_roster(data)
+          update(data)
+          data
+        end
+        def queue_roster
+          url, headers, options, timeout = api.get_request_info(path_roster)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_roster)}
+        end
+
+        def get_season_stats(year = Date.today.year)
+          data = api.get_data(path_season_stats(year))
+          ingest_season_stats(data)
+        end
+        def ingest_season_stats(data)
+          parse_season_stats(data)
+        end
+        def queue_season_stats
+          url, headers, options, timeout = api.get_request_info(path_season_stats)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_season_stats)}
+        end
+
+        # url path helpers
+        def path_base
+          "teams/#{ id }"
+        end
+        def path_base_stats(season_year = api.default_year, default_season = api.default_season)
+          "seasontd/#{season_year}/#{default_season}/teams/#{id}"
+        end
+        def path_roster
+          "#{ path_base }/profile"
+        end
+        def path_season_stats(year)
+          "#{ path_base_stats(year) }/statistics"
+        end
+
+        def api
+          @api || Sportradar::Api::Baseball::Mlb.new
+        end
+
+      end
+    end
+  end
+end

data/lib/sportradar/api/baseball/venue.rb

@@ -0,0 +1,51 @@
+module Sportradar
+  module Api
+    module Baseball
+      class Venue < Data
+        attr_accessor :response, :id, :name, :address, :city, :state, :country, :zip, :capacity, :timezone
+        @all_hash = {}
+        def self.new(data, **opts)
+          existing = @all_hash[data['id']]
+          if existing
+            existing.update(data, **opts)
+            existing
+          else
+            @all_hash[data['id']] = super
+          end
+        end
+        def self.all
+          @all_hash.values
+        end
+
+        def initialize(data, **opts)
+          @response = data
+          @id       = data["id"]
+
+          update(data, **opts)
+        end
+        def update(data, **opts)
+          @name     = data['name']
+          @address  = data['address']
+          @city     = data['city']
+          @state    = data['state']
+          @zip      = data['zip']
+          @country  = data['country']
+          @capacity = data['capacity']
+          @timezone = data['timezone']
+
+          @surface  = data['surface']
+
+          # dimensions
+        end
+
+        def location
+          "#{name}, #{city}"
+        end
+
+        KEYS_SCHEDULE = ["id", "name", "capacity", "address", "city", "state", "zip", "country"]
+      end
+    end
+  end
+end
+
+__END__

data/lib/sportradar/api/baseball.rb

@@ -0,0 +1,46 @@
+# require_relative 'baseball/season'
+require_relative 'baseball/game'
+require_relative 'baseball/outcome'
+require_relative 'baseball/team'
+require_relative 'baseball/record'
+require_relative 'baseball/venue'
+require_relative 'baseball/inning'
+require_relative 'baseball/half_inning'
+require_relative 'baseball/error'
+require_relative 'baseball/fielder'
+require_relative 'baseball/runner'
+require_relative 'baseball/event'
+require_relative 'baseball/events/at_bat'
+require_relative 'baseball/events/lineup'
+require_relative 'baseball/events/warming_up'
+require_relative 'baseball/pitch'
+require_relative 'baseball/player'
+require_relative 'baseball/lineup'
+# require_relative 'baseball/broadcast'
+# require_relative 'baseball/injury'
+require_relative 'baseball/scoring'
+
+require_relative 'baseball/mlb'
+require_relative 'baseball/mlb/hierarchy'
+require_relative 'baseball/mlb/league'
+require_relative 'baseball/mlb/division'
+# require_relative 'baseball/mlb/season'
+# require_relative 'baseball/mlb/schedule'
+# require_relative 'baseball/mlb/game'
+# require_relative 'baseball/mlb/team'
+# require_relative 'baseball/mlb/player'
+# require_relative 'baseball/mlb/quarter'
+
+# require_relative 'baseball/ncaamb'
+# require_relative 'baseball/ncaamb/season'
+# require_relative 'baseball/ncaamb/schedule'
+# require_relative 'baseball/ncaamb/tournament'
+# require_relative 'baseball/ncaamb/round'
+# require_relative 'baseball/ncaamb/bracket'
+# require_relative 'baseball/ncaamb/game'
+# require_relative 'baseball/ncaamb/half'
+# require_relative 'baseball/ncaamb/hierarchy'
+# require_relative 'baseball/ncaamb/division'
+# require_relative 'baseball/ncaamb/conference'
+# require_relative 'baseball/ncaamb/team'
+# require_relative 'baseball/ncaamb/player'

data/lib/sportradar/api/basketball/broadcast.rb

@@ -0,0 +1,15 @@
+module Sportradar
+  module Api
+    module Basketball
+      class Broadcast < Data
+        attr_accessor :response, :network
+
+        def initialize(data)
+          @response = data
+          @network = data["network"]
+        end
+
+      end
+    end
+  end
+end

data/lib/sportradar/api/basketball/game.rb

@@ -0,0 +1,339 @@
+module Sportradar
+  module Api
+    module Basketball
+      class Game < Data
+        attr_accessor :response, :id, :title, :home_id, :away_id, :score, :status, :coverage, :scheduled, :venue, :broadcast, :clock, :duration, :attendance, :team_stats, :player_stats, :changes, :media_timeouts
+
+        attr_accessor :period
+        @all_hash = {}
+        # def self.new(data, **opts)
+        #   existing = @all_hash[data['id']]
+        #   if existing
+        #     existing.update(data, **opts)
+        #     existing
+        #   else
+        #     @all_hash[data['id']] = super
+        #   end
+        # end
+        # def self.all
+        #   @all_hash.values
+        # end
+
+        def initialize(data, **opts)
+          @response = data
+          @api      = opts[:api]
+          # @season   = opts[:season]
+          @updates  = {}
+          @changes  = {}
+
+          @score          = {}
+          @team_stats     = {}
+          @player_stats   = {}
+          @scoring_raw    = Scoring.new(data, game: self)
+          @teams_hash     = {}
+          @periods_hash   = {}
+          @home_points    = nil
+          @away_points    = nil
+          @home_id        = nil
+          @away_id        = nil
+
+          @id = data['id']
+
+          update(data, **opts)
+        end
+        def timeouts
+          {}
+        end
+
+        def tied?
+          @score[away_id].to_i == @score[home_id].to_i
+        end
+        def points(team_id)
+          team_id.is_a?(Symbol) ? @score[@team_ids[team_id]].to_i : @score[team_id].to_i
+        end
+        def stats(team_id)
+          team_id.is_a?(Symbol) ? @team_stats[@team_ids[team_id]].to_i : @team_stats[team_id].to_i
+        end
+
+        def scoring
+          @scoring_raw.scores
+        end
+        def update_score(score)
+          @score.merge!(score)
+        end
+        def update_stats(team, stats)
+          @team_stats.merge!(team.id => stats.merge!(team: team))
+        end
+        def update_player_stats(player, stats)
+          @player_stats.merge!(player.id => stats.merge!(player: player))
+        end
+
+        def parse_score(data)
+          update_score(data.dig('home', 'id') => data.dig('home', 'points').to_i)
+          update_score(data.dig('away', 'id') => data.dig('away', 'points').to_i)
+        end
+        def clock_seconds
+          return unless @clock
+          m,s = @clock.split(':')
+          m.to_i * 60 + s.to_i
+        end
+
+        def update(data, source: nil, **opts)
+          # via pbp
+          @status       = data['status']                if data['status']
+          @coverage     = data['coverage']              if data['coverage']
+          @home_id      = data['home_team'] || data.dig('home', 'id')   if data['home_team'] || data.dig('home', 'id')
+          @away_id      = data['away_team'] || data.dig('away', 'id')   if data['away_team'] || data.dig('away', 'id')
+          @home_points  = data['home_points'].to_i      if data['home_points']
+          @away_points  = data['away_points'].to_i      if data['away_points']
+
+          @scheduled    = Time.parse(data["scheduled"]) if data["scheduled"]
+          @venue        = Venue.new(data['venue']) if data['venue']
+          @broadcast    = Broadcast.new(data['broadcast']) if !data['broadcast'].to_h.empty?
+          @home         = team_class.new(data['home'], api: api, game: self) if data['home']
+          @away         = team_class.new(data['away'], api: api, game: self) if data['away']
+          @title        = data['title'] || @title || (home && away && "#{home.full_name} vs #{away.full_name}")
+
+          @duration     = data['duration']              if data['duration']
+          @clock        = data['clock']                 if data['clock']
+          @attendance   = data['attendance']            if data['attendance']
+          @lead_changes = data['lead_changes']          if data['lead_changes']
+          @times_tied   = data['times_tied']            if data['times_tied']
+
+          @team_ids     = { home: @home_id, away: @away_id}
+
+          update_score(@home_id => @home_points.to_i) if @home_points
+          update_score(@away_id => @away_points.to_i) if @away_points
+          parse_score(data['scoring']) if data['scoring']
+          @scoring_raw.update(data, source: source)
+
+          create_data(@teams_hash, data['team'], klass: team_class, api: api, game: self) if data['team']
+        end
+
+        def home
+          @teams_hash[@home_id] || @home
+        end
+
+        def away
+          @teams_hash[@away_id] || @away
+        end
+
+        def leading_team_id
+          return nil if score.values.uniq.size == 1
+          score.max_by(&:last).first
+        end
+        def leading_team
+          @teams_hash[leading_team_id] || (@away_id == leading_team_id && away) || (@home_id == leading_team_id && home)
+        end
+        def team(team_id)
+          @teams_hash[team_id]
+        end
+        def assign_home(team)
+          @home_id = team.id
+          @teams_hash[team.id] = team
+        end
+        def assign_away(team)
+          @away_id = team.id
+          @teams_hash[team.id] = team
+        end
+
+        def box
+          @box ||= get_box
+        end
+        def pbp
+          if !future? && periods.empty?
+            get_pbp
+          end
+          @pbp ||= periods
+        end
+        def plays
+          periods.flat_map(&:plays)
+        end
+        def plays_by_type(play_type, *types)
+          if types.empty?
+            plays.grep(Play.subclass(play_type.delete('_')))
+          else
+            play_classes = [play_type, *types].map { |type| Play.subclass(type.delete('_')) }
+            plays.select { |play| play_classes.any? { |klass| play.kind_of?(klass) } }
+          end
+        end
+        def summary
+          @summary ||= get_summary
+        end
+        alias :events :plays
+
+        def periods
+          @periods_hash.values
+        end
+
+
+        # tracking updates
+        def remember(key, object)
+          @updates[key] = object&.dup
+        end
+        def not_updated?(key, object)
+          @updates[key] == object
+        end
+        def changed?(key)
+          @changes[key]
+        end
+        def check_newness(key, new_object)
+          @changes[key] = !not_updated?(key, new_object)
+          remember(key, new_object)
+        end
+
+        # url paths
+        def path_base
+          "games/#{ id }"
+        end
+        def path_box
+          "#{ path_base }/boxscore"
+        end
+        def path_pbp
+          "#{ path_base }/pbp"
+        end
+        def path_summary
+          "#{ path_base }/summary"
+        end
+
+        # status helpers
+        def realtime_state
+          if future?
+            'Scheduled'
+          elsif finished?
+            'Final'
+          elsif postponed?
+            'Postponed'
+          # elsif halftime?
+          #   'Halftime'
+          else
+            clock_display
+          end
+        end
+
+        def clock_display
+          if clock && period
+            "#{clock} #{period_display}"
+          end
+        end
+        def period_display
+          if period > 5
+            "#{period - 4}OT"
+          elsif period == 5
+            'OT'
+          else
+            "#{period}Q"
+          end
+        end
+
+        def postponed?
+          'postponed' == status
+        end
+        def unnecessary?
+          'unnecessary' == status
+        end
+        def cancelled?
+          ['unnecessary', 'postponed'].include? status
+        end
+        def future?
+          ['scheduled', 'delayed', 'created', 'time-tbd', 'if-necessary'].include? status
+        end
+        def started?
+          ['inprogress', 'halftime', 'delayed'].include? status
+        end
+        def finished?
+          ['complete', 'closed'].include? status
+        end
+        def completed?
+          'complete' == status
+        end
+        def closed?
+          'closed' == status
+        end
+
+        # data retrieval
+
+        def get_box
+          data = api.get_data(path_box)
+          ingest_box(data)
+        end
+
+        def ingest_box(data)
+          update(data, source: :box)
+          @period = data.delete(period_name).to_i
+          check_newness(:box, @clock)
+          data
+        end
+
+        def queue_pbp
+          url, headers, options, timeout = api.get_request_info(path_pbp)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_pbp)}
+        end
+
+        def get_pbp
+          data = api.get_data(path_pbp)
+          ingest_pbp(data)
+        end
+
+        def ingest_pbp(data)
+          period_name = 'periods'
+          update(data, source: :pbp)
+          period_data = if data[period_name] && !data[period_name].empty?
+            @period = data[period_name].last['sequence'].to_i
+            pers = data[period_name]
+            pers.is_a?(Array) && (pers.size == 1) ? pers[0] : pers
+          else
+            @period = nil
+            []
+          end
+          if data['overtime']
+            extra_periods = data['overtime'].is_a?(Hash) ? [data['overtime']] : data['overtime']
+            period_data.concat(extra_periods)
+          end
+          set_pbp(period_data)
+          @pbp = @periods_hash.values
+          check_newness(:pbp, plays.last&.updated)
+          check_newness(:score, @score)
+          data
+        end
+
+        def get_summary
+          data = api.get_data(path_summary)
+          ingest_summary(data)
+        end
+
+        def queue_summary
+          url, headers, options, timeout = api.get_request_info(path_summary)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_summary)}
+        end
+
+        def ingest_summary(data)
+          update(data, source: :summary)
+          @period = data.delete(period_name).to_i
+          check_newness(:box, @clock)
+          check_newness(:score, @score)
+          data
+        end
+
+        def set_pbp(data)
+          create_data(@periods_hash, data, klass: period_class, api: api, game: self)
+          @plays  = nil # to clear empty array empty
+          @periods_hash
+        end
+
+        # @abstract Subclass is expected to implement #period_class
+        # @!method period_class
+        #    The class used for game periods
+
+        # @abstract Subclass is expected to implement #period_name
+        # @!method period_name
+        #    The string name used for game periods
+
+        # @abstract Subclass is expected to implement #api
+        # @!method api
+        #    The base for the requests needed for a subclass
+
+      end
+    end
+  end
+end

data/lib/sportradar/api/basketball/injury.rb

@@ -0,0 +1,41 @@
+module Sportradar
+  module Api
+    module Basketball
+      class Injury < Data
+        attr_accessor :response, :id, :comment, :descripton, :status, :start_date, :update_date
+
+        def initialize(data, **opts)
+          @response = data
+          update(data, **opts)
+        end
+
+        def update(data, **opts)
+          @id           = data.last&.dig('id')
+          @comment      = data.last&.dig('comment')
+          @descripton   = data.last&.dig('desc')
+          @status       = data.last&.dig('status')
+          @start_date   = data.last&.dig('start_date')
+          @update_date  = data.last&.dig('update_date')
+        end
+
+        def out?
+          @status == 'Out'
+        end
+
+        private def sample_data
+          {
+            "injury" => {
+              "id"         => "069a9d3f-036e-4dab-9b49-d2e75082230e",
+              "comment"    => "Paul will have surgery to repair torn ligaments in his left thumb and is expected to be out for six-to-eight weeks to recover, according to a report from ESPN.com.",
+              "desc"       => "Thumb",
+              "status"     => "Out",
+              "start_date" => "2017-01-17",
+              "update_date"=> "2017-01-17"
+            }
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/sportradar/api/basketball/nba/conference.rb

@@ -0,0 +1,27 @@
+module Sportradar
+  module Api
+    module Basketball
+      class Nba
+        class Conference < Data
+          attr_accessor :response, :id, :name, :alias
+
+          def initialize(data, **opts)
+            @response = data
+            @api      = opts[:api]
+
+            @id = data["id"]
+            @name = data["name"]
+            @alias = data["alias"]
+            @divisions_hash = create_data({}, data["divisions"], klass: Division, conference: self, api: @api) # if response["division"]
+          end
+
+          def divisions
+            @divisions_hash.values
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/sportradar/api/basketball/nba/division.rb

@@ -0,0 +1,30 @@
+module Sportradar
+  module Api
+    module Basketball
+      class Nba
+        class Division < Data
+          attr_accessor :response, :id, :name, :alias
+
+          def initialize(data, **opts)
+            @response = data
+            @api      = opts[:api]
+
+            @id = data["id"]
+            @name = data["name"]
+            @alias = data["alias"]
+            @assigned_teams = nil
+            @teams_hash = create_data({}, data["teams"], klass: Team, division: self, api: @api) # if response["team"]
+          end
+
+          def teams
+            @assigned_teams || @teams_hash.values
+          end
+          def teams=(array)
+            @assigned_teams = array
+          end
+
+        end
+      end
+    end
+  end
+end