sportradar-api 0.10.55 → 0.11.0

data/lib/sportradar/api/nfl/changelog.rb

@@ -1,17 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Changelog < Data
-      attr_accessor :response, :start_time, :end_time, :players, :games
-
-      def initialize(data)
-        @response = data
-        @start_time = data["start_time"]
-        @end_time = data["end_time"]
-        @games = parse_into_array(selector: response["game"], klass: Sportradar::Api::Nfl::Game) if response["game"]
-        @players = parse_into_array(selector: response["profiles"]["players"]["player"], klass: Sportradar::Api::Nfl::Player) if response["profiles"] && response["profiles"]["players"] && response["profiles"]["players"]["player"]
-      end
-
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/coach.rb

@@ -1,17 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Coach < Data
-      attr_accessor :response, :id, :full_name, :first_name, :last_name, :position
-
-      def initialize(data)
-        @response = data
-        @id = data["id"]
-        @full_name = data["full_name"]
-        @first_name = data["first_name"]
-        @last_name = data["last_name"]
-        @position = data["position"]
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/conference.rb

@@ -1,17 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Conference < Data
-      attr_accessor :response, :id, :name, :alias, :divisions
-
-      def initialize(data, **opts)
-        @response = data
-        @api      = opts[:api]
-        @id = data["id"]
-        @name = data["name"]
-        @alias = data["alias"]
-        @divisions = parse_into_array(selector: response["division"], klass: Sportradar::Api::Nfl::Division) if response["division"]
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/depth_chart.rb

@@ -1,47 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::DepthChart < Data
-      include Enumerable
-      attr_accessor :response, :chart
-
-      def initialize(data)
-        generate_chart(data)
-      end
-
-      def team(number)
-        teams[number]
-      end
-
-      def each
-        populate_teams
-        teams.each { |team| yield team }
-      end
-
-      private
-
-      def teams
-        @teams ||= populate_teams
-      end
-
-      def populate_teams
-        (1..3).each_with_object({}) do |i, hash|
-          hash[i] = generate_team(i)
-        end
-      end
-
-      def generate_team(number)
-        @chart.each_with_object({}) do |(pos_name, groups), memo|
-          memo[pos_name] = groups[number.to_s]
-        end
-      end
-
-      def generate_chart(data)
-        @chart = data['position'].each_with_object({}) do |position, memo|
-          players = position['player'].map { |h| Sportradar::Api::Nfl::Player.new(h) }
-          memo[position['name']] = players.group_by(&:depth)
-        end
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/division.rb

@@ -1,16 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Division < Data
-      attr_accessor :response, :id, :name, :alias, :teams
-
-      def initialize(data)
-        @response = data
-        @id = data["id"]
-        @name = data["name"]
-        @alias = data["alias"]
-        @teams = parse_into_array(selector: response["team"], klass: Sportradar::Api::Nfl::Team) if response["team"]
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/draft.rb

@@ -1,16 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Draft < Data
-      attr_accessor :response, :year, :round, :number, :team
-
-      def initialize(data)
-        @response = data
-        @year = data["year"]
-        @round = data["round"]
-        @number = data["number"]
-        @team = Sportradar::Api::Nfl::Team.new data["team"] if data["team"]
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/drive.rb

@@ -1,73 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Drive < Data
-      attr_accessor :response, :id, :sequence, :start_reason, :end_reason, :play_count, :duration, :first_downs, :gain, :penalty_yards, :scoring_drive, :quarter, :team, :plays, :events
-
-      def initialize(data)
-        @response = data
-        @id = data["id"]
-        @sequence = data["sequence"]
-        @start_reason = data["start_reason"]
-        @end_reason = data["end_reason"]
-        @play_count = data["play_count"]
-        @duration = data["duration"]
-        @first_downs = data["first_downs"]
-        @gain = data["gain"]
-        @penalty_yards = data["penalty_yards"]
-        @scoring_drive = data["scoring_drive"]
-        @quarter = Sportradar::Api::Nfl::Quarter.new data["quarter"] if data["quarter"]
-        @team = Sportradar::Api::Nfl::Team.new data["team"] if data["team"]
-        @plays = parse_into_array(selector: response["play"], klass: Sportradar::Api::Nfl::Play) if response["play"]
-        @plays ||= parse_into_array(selector: response["plays"]["play"], klass: Sportradar::Api::Nfl::Play) if response["plays"] && response["plays"]["play"]
-        @events = parse_into_array(selector: response["event"], klass: Sportradar::Api::Nfl::Event) if response["event"]
-      end
-
-      def end_reason_possibilities
-        [
-          'UNKNOWN',
-          'Touchdown',
-          'Safety',
-          'Field Goal',
-          'Missed FG',
-          'Blocked FG',
-          'Blocked FG, Downs',
-          'Blocked FG, Safety',
-          'Punt',
-          'Blocked Punt',
-          'Blocked Punt, Downs',
-          'Blocked Punt, Safety',
-          'Downs',
-          'Interception',
-          'Fumble',
-          'Fumble, Safety',
-          'Muffed FG',
-          'Muffed Punt',
-          'Muffed Kickoff',
-          'Kickoff',
-          'Own Kickoff',
-          'Onside Kick',
-          'Kickoff, No Play',
-          'End of Half',
-          'End of Game',
-        ]
-      end
-      def normalized_end_reason
-        case end_reason
-        when 'Touchdown'
-          'Touchdown'
-        when 'Field Goal', 'Missed FG', "Blocked FG, Downs", 'Muffed FG', 'Blocked FG, Safety'
-          'Field Goal'
-        when 'Downs'
-          'Downs'
-        when 'Interception', 'Fumble'
-          'Turnover'
-        when 'Punt'
-          'Punt'
-        else
-          'Other'
-        end
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/event.rb

@@ -1,19 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Event < Data
-      attr_accessor :response, :id, :sequence, :reference, :clock, :type, :description, :alt_description
-
-      def initialize(data)
-        @response = data
-        @id = data["id"]
-        @sequence = data["sequence"]
-        @reference = data["reference"]
-        @clock = data["clock"]
-        @type = data["type"]
-        @description = data["description"]
-        @alt_description = data["alt_description"]
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/franchise.rb

@@ -1,14 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Franchise < Data
-      attr_accessor :response, :name, :alias
-
-      def initialize(data)
-        @response = data
-        @name = data["name"]
-        @alias = data["alias"]
-      end
-
-    end
-  end
-end

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

@@ -1,123 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Game < Data
-      attr_accessor :response, :id, :status, :reference, :number, :scheduled, :entry_mode, :venue, :home, :away, :broadcast, :number, :attendance, :utc_offset, :weather, :clock, :quarter, :summary, :situation, :last_event, :scoring, :scoring_drives, :quarters, :stats, :week, :season, :overtime
-
-      def initialize(data)
-        @response = data
-        @id = data["id"]
-
-        @status = data["status"]
-        @reference = data["reference"]
-        @number = data["number"]
-        @scheduled = Time.parse(data["scheduled"]) if data["scheduled"]
-        @week = Sportradar::Api::Nfl::Week.new data.dig("summary", "week") if data.dig("summary", "week")
-        @season = Sportradar::Api::Nfl::Season.new data.dig("summary", "season") if data.dig("summary", "season")
-        @entry_mode = data["entry_mode"]
-
-        # game boxscore
-        @number = data["number"]
-        @attendance = data["attendance"]
-        @utc_offset = data["utc_offset"]
-        @weather = data["weather"]
-        @clock = data["clock"]
-
-        if data["quarter"]
-          @quarter = data["quarter"][0]
-          quarter_data = data["quarter"][1].is_a?(Hash) ? data["quarter"][1..-1] : data["quarter"][1]
-          @quarters = quarter_data&.map { |hash| Sportradar::Api::Nfl::Quarter.new(hash) }
-        end
-
-        if data["overtime"]
-          @overtime = parse_into_array(selector: data['overtime'], klass: Sportradar::Api::Nfl::Quarter)
-          @quarters.concat(@overtime)
-        end
-
-        @summary = Sportradar::Api::Nfl::Summary.new data["summary"] if data["summary"]
-        @situation = Sportradar::Api::Nfl::Situation.new data["situation"] if data["situation"]
-        @last_event = Sportradar::Api::Nfl::Event.new data["last_event"]["event"] if data["last_event"] && data["last_event"]["event"]
-        @scoring = Sportradar::Api::Nfl::Scoring.new data["scoring"] if data["scoring"]
-
-        @scoring_drives = parse_into_array(selector: response["scoring_drives"]["drive"], klass: Sportradar::Api::Nfl::Drive)  if response["scoring_drives"] && response["scoring_drives"]["drive"]
-
-        location = data["summary"] || data
-        @venue = Sportradar::Api::Nfl::Venue.new data["venue"] || location["venue"] if data["venue"] || location["venue"]
-        @home = Sportradar::Api::Nfl::Team.new   data["home"]  || location["home"]  if data["home"]  || location["home"]
-        @away = Sportradar::Api::Nfl::Team.new   data["away"]  || location["away"]  if data["away"]  || location["away"]
-
-        @broadcast = Sportradar::Api::Nfl::Broadcast.new data["broadcast"] if data["broadcast"]
-
-        if data["team"]
-          @stats = data["team"].map { |team_stat| [team_stat["id"], Sportradar::Api::Nfl::GameStatistic.new(team_stat)] }.to_h
-          @home.stats = @stats[@home.id]
-          @away.stats = @stats[@away.id]
-        end
-
-      end
-
-      def overtime?
-        !overtime.nil?
-      end
-
-      def full_name
-        "#{away.full_name} vs #{home.full_name}"
-      end
-
-      def name
-        "#{away.name} vs #{home.name}"
-      end
-      def started?
-        ['inprogress', 'halftime', 'delayed'].include?(status)
-      end
-      def finished?
-        status == "closed"
-      end
-
-      def sport_league
-        'NFL'.freeze
-      end
-
-      def current_score
-        "#{summary.home.points}-#{summary.away.points}" if summary
-      end
-
-      def drives
-        @drives ||= begin
-          drives = Array(quarters&.flat_map(&:drives)).compact
-          # Scan for duplicates
-          drives.each_cons(2) do |a,b|
-            # Merge plays and events into the first if duplicate and flag dup for removal
-            if a.id == b.id
-              Array(a.plays).concat(b.plays)
-              Array(a.events).concat(Array(b.events)).uniq!
-              b.id = nil
-            end
-          end
-          # Remove the dup
-          drives.delete_if{ |d| d.id.nil? }
-        end
-      end
-
-      def plays
-        Array(drives&.flat_map(&:plays)).compact
-      end
-
-      def status_description
-        status_description = {
-           "scheduled" => "The game is currently scheduled to occur.",
-           "inprogress" => "The game is currently in progress.",
-           "halftime" => "The game is currently at the half.",
-           "complete" => "The game is over, but the statistics validation process has not been completed.",
-           "closed" => "The game is over and the game statistics have been validated.",
-           "cancelled" => "The game has been cancelled.",
-           "postponed" => "The scheduled game has been postponed for some reason.",
-           "delayed" => "The scheduled game, or a game that was in progress, is now delayed for some reason.",
-           "flex-schedule" => "The game is currently scheduled to occur on a specific date and time, however, it will more than likely be moved to a different time for broadcast purposes.",
-           "time-tbd" => "The game is scheduled to occur, the date is known, but the start time has not been determined.",
-         }
-         status_descriptions[status] if status
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/game_statistic.rb

@@ -1,133 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::GameStatistic < Data
-      attr_accessor :response, :id, :efficiency, :first_downs, :interceptions, :touchdowns, :name, :market, :alias, :reference, :possession_time, :avg_gain, :safeties, :turnovers, :play_count, :rush_plays, :total_yards, :lost_fumbles, :penalty_yards, :return_yards
-
-      # attr_writer :rushing, :receiving, :punts, :punt_returns, :penalties, :passing, :misc_returns, :kickoffs, :kick_returns, :int_returns, :fumbles, :field_goals, :extra_points, :defense # probably not necessary, but leaving here in case we want it later
-
-      def initialize(data)
-        @response        = data
-        @id              = data["id"]
-        @name            = data["name"]
-        @market          = data["market"]
-        @alias           = data["alias"]
-        @reference       = data["reference"]
-        @efficiency      = data["efficiency"]
-        @first_downs     = data["first_downs"]
-        @interceptions   = data["interceptions"]
-        @touchdowns      = data["touchdowns"]
-        @possession_time = data["possession_time"]
-        @avg_gain        = data["avg_gain"]
-        @safeties        = data["safeties"]
-        @turnovers       = data["turnovers"]
-        @play_count      = data["play_count"]
-        @rush_plays      = data["rush_plays"]
-        @total_yards     = data["total_yards"]
-        @lost_fumbles    = data["lost_fumbles"]
-        @penalty_yards   = data["penalty_yards"]
-        @return_yards    = data["return_yards"]
-      end
-
-      # :skip_test_coverage:
-      # These are in methods rather than attributes to use them lazily. Each one is tested in it's respective class
-      def rushing
-        if response["rushing"]
-          response["rushing"] = parse_out_hashes response["rushing"]
-          @rushing       ||= Sportradar::Api::Football::StatPack::Rushing.new(response["rushing"])
-        end
-      end
-
-      def receiving
-        if response["receiving"]
-          response["receiving"] = parse_out_hashes response["receiving"]
-          @receiving     ||= Sportradar::Api::Football::StatPack::Receiving.new(response["receiving"])
-        end
-      end
-
-      def punts
-        if response["punts"]
-          response["punts"] = parse_out_hashes response["punts"]
-          @punts         ||= Sportradar::Api::Football::StatPack::Punts.new(response["punts"])
-        end
-      end
-
-      def punt_returns
-        if response["punt_returns"]
-          response["punt_returns"] = parse_out_hashes response["punt_returns"]
-          @punt_returns  ||= Sportradar::Api::Football::StatPack::PuntReturns.new(response["punt_returns"])
-        end
-      end
-
-      def penalties
-        if response["penalties"]
-          response["penalties"] = parse_out_hashes response["penalties"]
-          @penalties     ||= Sportradar::Api::Football::StatPack::Penalties.new(response["penalties"])
-        end
-      end
-
-      def passing
-        if response["passing"]
-          response["passing"] = parse_out_hashes response["passing"]
-          @passing       ||= Sportradar::Api::Football::StatPack::Passing.new(response["passing"])
-        end
-      end
-
-      def misc_returns
-        if response["misc_returns"]
-          response["misc_returns"] = parse_out_hashes response["misc_returns"]
-          @misc_returns  ||= Sportradar::Api::Football::StatPack::MiscReturns.new(response["misc_returns"])
-        end
-      end
-
-      def kickoffs
-        if response["kickoffs"]
-          response["kickoffs"] = parse_out_hashes response["kickoffs"]
-          @kickoffs      ||= Sportradar::Api::Football::StatPack::Kickoffs.new(response["kickoffs"])
-        end
-      end
-
-      def kick_returns
-        if response["kick_returns"]
-          response["kick_returns"] = parse_out_hashes response["kick_returns"]
-          @kick_returns  ||= Sportradar::Api::Football::StatPack::KickReturns.new(response["kick_returns"])
-        end
-      end
-
-      def int_returns
-        if response["int_returns"]
-          response["int_returns"] = parse_out_hashes response["int_returns"]
-          @int_returns   ||= Sportradar::Api::Football::StatPack::IntReturns.new(response["int_returns"])
-        end
-      end
-
-      def fumbles
-        if response["fumbles"]
-          response["fumbles"] = parse_out_hashes response["fumbles"]
-          @fumbles       ||= Sportradar::Api::Football::StatPack::Fumbles.new(response["fumbles"])
-        end
-      end
-
-      def field_goals
-        if response["field_goals"]
-          response["field_goals"] = parse_out_hashes response["field_goals"]
-          @field_goals   ||= Sportradar::Api::Football::StatPack::FieldGoals.new(response["field_goals"])
-        end
-      end
-
-      def extra_points
-        if response["extra_points"]
-          response["extra_points"] = parse_out_hashes response["extra_points"]
-          @extra_points  ||= Sportradar::Api::Football::StatPack::ExtraPoints.new(response["extra_points"])
-        end
-      end
-
-      def defense
-        if response["defense"]
-          response["defense"] = parse_out_hashes response["defense"]
-          @defense       ||= Sportradar::Api::Football::StatPack::Defense.new(response["defense"])
-        end
-      end
-      # :skip_test_coverage:
-    end
-  end
-end

data/lib/sportradar/api/nfl/hierarchy.rb

@@ -1,19 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Hierarchy < Data
-      attr_accessor :response, :id, :name, :alias, :divisions, :conferences, :teams
-
-      def initialize(data)
-        @response = data
-        @id = data["id"]
-        @name = data["name"]
-        @alias = data["alias"]
-        @conferences = parse_into_array(selector: data["conference"], klass: Sportradar::Api::Nfl::Conference)  if data["conference"]
-        @divisions = conferences.flat_map(&:divisions) if conferences&.all? { |conference| conference.divisions }
-        @divisions ||= parse_into_array(selector: data["division"], klass: Sportradar::Api::Nfl::Division)  if data["division"]
-        @teams = @divisions.flat_map(&:teams) if divisions&.all? {|division| division.teams }
-      end
-
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Injury < Data
-      attr_accessor :response, :status, :status_date, :practice, :primary
-
-      def initialize(data)
-        @response = data
-        @status = data["status"]
-        @status_date = data["status_date"]
-        @practice = OpenStruct.new data["practice"] if data['practice']
-        @primary = data["primary"]
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/league_depth_chart.rb

@@ -1,26 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::LeagueDepthChart < Data
-      include Enumerable
-      attr_accessor :response, :season, :charts
-
-      def initialize(data)
-        @response = data
-        depth_chart_data = data['depth_charts']
-        @season = Sportradar::Api::Nfl::Season.new data
-        # @teams = depth_chart_data["team"].map {|team| Sportradar::Api::Nfl::Team.new team } if depth_chart_data["team"]
-        @charts = depth_chart_data["team"].map {|team| Sportradar::Api::Nfl::TeamDepthChart.new(team, season) } if depth_chart_data["team"]
-      end
-
-      # id is preferred search, but we allow for team abbreviation too
-      def team(id = nil, abbrev: nil)
-        @charts.detect { |chart| chart.team_id == id || chart.abbrev == abbrev }
-      end
-
-      def each
-        self.charts.each { |chart| yield chart }
-      end
-
-    end
-  end
-end

data/lib/sportradar/api/nfl/play.rb

@@ -1,39 +0,0 @@
-module Sportradar
-  module Api
-    class Nfl::Play < Data
-      attr_accessor :response, :id, :sequence, :reference, :clock, :home_points, :away_points, :type, :play_clock, :wall_clock, :start_situation, :end_situation, :description, :alt_description, :statistics, :score, :scoring_play, :team_id, :player_id
-
-      def initialize(data)
-        @response = data
-        @alt_description = data["alt_description"]
-        @away_points = data["away_points"]
-        @clock = data["clock"]
-        @description = data["description"]
-        @end_situation = Sportradar::Api::Nfl::Situation.new data["end_situation"] if data["end_situation"]
-        @team_id = end_situation.team_id if end_situation
-        @home_points = data["home_points"]
-        @id = data["id"]
-        @play_clock = data["play_clock"]
-        @reference = data["reference"]
-        @score = data["score"]
-        @scoring_play = data["scoring_play"]
-        @sequence = data["sequence"]
-        @start_situation = Sportradar::Api::Nfl::Situation.new data["start_situation"] if data["start_situation"]
-        @statistics = Sportradar::Api::Nfl::PlayStatistics.new data["statistics"] if data["statistics"]
-        parse_player if @statistics
-        @type = data["type"]
-        @wall_clock = data["wall_clock"]
-      end
-
-      def parse_player
-        # TODO: Currently there is an issue where we are only mapping one player_id to a play, but there are plays with multiple players involved.
-        play_stats = @statistics.penalty || @statistics.rush || @statistics.return || @statistics.receive
-        if play_stats.is_a?(Array)
-          play_stats = play_stats.first
-        end
-        @player_id = play_stats&.player&.id
-      end
-
-    end
-  end
-end