sportradar-api 0.12.3 → 0.13.0

data/lib/sportradar/api/soccer/match.rb

@@ -1,55 +1,235 @@
 module Sportradar
   module Api
-    class Soccer::Match < Data
-
-      attr_accessor :id, :status, :scheduled, :scratched, :season_id, :reference_id, :category, :tournament_group, :tournament, :home, :away, :venue, :round, :coverage, :period, :clock, :referee, :facts, :response, :future_game, :winner
-
-      def initialize(data)
-        @response = data
-        @id = data["id"]
-        @reference_id = data["reference_id"]
-        @scheduled = Time.parse(data["scheduled"]) if data["scheduled"]
-        @scratched = data["scratched"] == "true"
-        @season_id = data["season_id"]
-        @status = data["status"]
-        @category = Sportradar::Api::Soccer::Category.new data["category"] if data["category"]
-        @coverage = OpenStruct.new data["coverage"]
-        @round = OpenStruct.new data["round"]
-        @tournament = Sportradar::Api::Soccer::Tournament.new data["tournament"] if data["tournament"]
-        @tournament_group = Sportradar::Api::Soccer::TournamentGroup.new data["tournament_group"] if data["tournament_group"]
-
-        @away = Sportradar::Api::Soccer::Team.new data["away"] if data["away"]
-        @home = Sportradar::Api::Soccer::Team.new data["home"] if data["home"]
-        @venue = Sportradar::Api::Soccer::Venue.new data["venue"] if data["venue"]
-
-        @future_game = @scheduled > Time.now.utc
-        @winner = find_winner if @home && @away && !future_game
-
-        # Actual stats from match summary
-        @period = data["period"]
-        @clock = data["clock"]
-        @referee = OpenStruct.new data["referee"] if data["referee"]
-        @facts = data["facts"]["fact"].map {|fact| Sportradar::Api::Soccer::Fact.new  fact } if data["facts"]
-      end
+    module Soccer
+      class Match < Data
+        attr_reader :id, :league_group, :scheduled, :start_time_tbd, :status, :tournament_round, :match_status, :venue
+        attr_reader :home_score, :away_score, :winner_id, :aggregate_home_score, :aggregate_away_score, :aggregate_winner_id
+        attr_reader :referee, :weather_info, :coverage_info, :probabilities
+        attr_reader :home, :away, :tournament_id
+
+        def initialize(data = {}, league_group: nil, **opts)
+          @response     = data
+          @id           = data['id']
+          @api          = opts[:api]
+
+          @league_group = league_group || data['league_group'] || @api&.league_group
+
+          @timeline_hash = {}
+          @lineups_hash  = {}
+          get_tournament_id(data, **opts)
+          @home          = Team.new({}, api: api, match: self)
+          @away          = Team.new({}, api: api, match: self)
+          @teams_hash    = { away: @away, home: @home }
 
-      def find_winner
-        if @home.winner == 'draw'
-          'draw'
-        else
-          [@home, @away].find {|team| team.winner == "true" }
+          update(data, **opts)
         end
 
-      end
+        def update(data, **opts)
+          @league_group = opts[:league_group] || data['league_group'] || @league_group
+          get_tournament_id(data, **opts)
+          if data["sport_event"]
+            update(data["sport_event"])
+          end
+          if data["sport_event_status"]
+            update(data["sport_event_status"])
+          end
+          if data['sport_event_conditions']
+            update(data['sport_event_conditions'])
+          end
+          if data['probabilities']
+            # update(data['probabilities'])
+            @probabilities = data['probabilities'] # tidy this up later
+          end
+          if data['lineups']
+            create_data(@lineups_hash, data['lineups'], klass: Lineup, identifier: 'team', api: api)
+          end
+          if (stats = data.dig('statistics', 'teams'))
+            update_teams(stats)
+          end
 
-      def period_name
-        period_names = {"P1" => "Period one", "H" => "Halftime", "P2" => "Period two", "PX1" => "Pre-extra time one", "X1" => "Extra time one", "PX2" => "Pre-extra time two", "X2" => "Extra time two", "PP" => "Pre-penalty", "P" => "Penalty"}
-        period_names[period] if period
-      end
 
-      def status_description
-        status_descriptions = {"scheduled" =>  "The match is scheduled to be played", "inprogress" =>  "The match is currently in progress", "postponed" =>  "The match has been postponed to a future date", "delayed" =>  "The match has been temporarily delayed and will be continued", "canceled" =>  "The match has been canceled and will not be played", "closed" =>  "The match is over"}
-        status_descriptions[status] if status
+          @scheduled        = Time.parse(data['scheduled'])         if data['scheduled']
+          @start_time_tbd   = data['start_time_tbd']                if data.key?('start_time_tbd')
+          @status           = data['status']                        if data['status']
+          @match_status     = data['match_status']                  if data['match_status']
+          @tournament_round = data['tournament_round']              if data['tournament_round']
+          @venue            = Venue.new(data['venue'])              if data['venue']
+          @weather_info     = OpenStruct.new(data["weather_info"])  if data["weather_info"]
+          @referee          = OpenStruct.new(data["referee"])       if data["referee"]
+          @coverage_info    = OpenStruct.new(data["coverage_info"]) if data["coverage_info"]
+
+          @home_score       = data['home_score']                    if data['home_score']
+          @away_score       = data['away_score']                    if data['away_score']
+          @winner_id        = data['winner_id']                     if data['winner_id']
+
+          @aggregate_home_score = data['aggregate_home_score']      if data['aggregate_home_score']
+          @aggregate_away_score = data['aggregate_away_score']      if data['aggregate_away_score']
+          @aggregate_winner_id  = data['aggregate_winner_id']       if data['aggregate_winner_id']
+          create_data(@timeline_hash, data['timeline'], klass: Event, api: api)
+          # @season
+          # @tournament
+          if data['competitors']
+            update_teams(data['competitors'])
+          end
+
+          # parse_nested_data(data)
+        end
+
+        def update_teams(data)
+          home_hash = data.detect { |team_hash| team_hash["qualifier"] == "home" || team_hash["team"] == "home" }
+          away_hash = (data - [home_hash]).first
+          if home_hash && away_hash
+            @home.update(home_hash, match: self)
+            @away.update(away_hash, match: self)
+            @teams_hash[@home.id] = @home
+            @teams_hash[@away.id] = @away
+          end
+        end
+
+        def get_tournament_id(data, **opts)
+          @tournament_id ||= if opts[:tournament]
+            opts[:tournament].id
+          elsif opts[:season]
+            opts[:season].tournament_id
+          elsif opts[:match]
+            opts[:match].tournament_id
+          elsif data['tournament']
+            data.dig('tournament', 'id')
+          elsif data['season']
+            data.dig('season', 'tournament_id')
+          end
+        end
+
+        def team(place_or_id)
+          @teams_hash[place_or_id]
+        end
+
+        def timeline(type = nil)
+          if type
+            @timeline_hash.each_value.select { |ev| ev.type == type }
+          else
+            @timeline_hash.values
+          end
+        end
+
+        def lineups(which = nil)
+          if which
+            @lineups_hash[which.to_s]
+          else
+            @lineups_hash.values
+          end
+        end
+
+        def api
+          @api ||= Sportradar::Api::Soccer::Api.new(league_group: @league_group)
+        end
+
+        def path_base
+          "matches/#{ id }"
+        end
+
+        def path_summary
+          "#{ path_base }/summary"
+        end
+        def get_summary
+          data = api.get_data(path_summary).to_h
+          ingest_summary(data)
+        end
+        def ingest_summary(data)
+          update(data)
+          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 path_lineups
+          "#{ path_base }/lineups"
+        end
+        def get_lineups
+          data = api.get_data(path_lineups).to_h
+          ingest_lineups(data)
+        end
+        def ingest_lineups(data)
+          update(data)
+          data
+        end
+        def queue_lineups
+          url, headers, options, timeout = api.get_request_info(path_lineups)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_lineups)}
+        end
+
+        def path_facts
+          "#{ path_base }/funfacts"
+        end
+        def get_facts
+          data = api.get_data(path_facts).to_h
+          ingest_facts(data)
+        end
+        def ingest_facts(data)
+          update(data)
+          data
+        end
+        def queue_facts
+          url, headers, options, timeout = api.get_request_info(path_facts)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_facts)}
+        end
+
+        def path_probabilities
+          "#{ path_base }/probabilities"
+        end
+        def get_probabilities
+          data = api.get_data(path_probabilities).to_h
+          ingest_probabilities(data)
+        end
+        def ingest_probabilities(data)
+          update(data)
+          data
+        end
+        def queue_probabilities
+          url, headers, options, timeout = api.get_request_info(path_probabilities)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_probabilities)}
+        end
+
+        def path_timeline
+          "#{ path_base }/timeline"
+        end
+        def get_timeline
+          data = api.get_data(path_timeline).to_h
+          ingest_timeline(data)
+        end
+        def ingest_timeline(data)
+          update(data)
+          data
+        end
+        def queue_timeline
+          url, headers, options, timeout = api.get_request_info(path_timeline)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_timeline)}
+        end
+
       end
     end
   end
 end
+
+__END__
+
+"id"=>"sr:match:12090446",
+"scheduled"=>"2018-05-20T18:45:00+00:00",
+"start_time_tbd"=>true,
+"status"=>"not_started",
+"tournament_round"=>{"type"=>"group", "number"=>38},
+"season"=>{"id"=>"sr:season:42720", "name"=>"Serie A 17/18", "start_date"=>"2017-08-19", "end_date"=>"2018-05-21", "year"=>"17/18", "tournament_id"=>"sr:tournament:23"},
+"tournament"=>{"id"=>"sr:tournament:23", "name"=>"Serie A", "sport"=>{"id"=>"sr:sport:1", "name"=>"Soccer"}, "category"=>{"id"=>"sr:category:31", "name"=>"Italy", "country_code"=>"ITA"}},
+"competitors"=>
+ [{"id"=>"sr:competitor:2793", "name"=>"US Sassuolo", "country"=>"Italy", "country_code"=>"ITA", "abbreviation"=>"SAS", "qualifier"=>"home"},
+  {"id"=>"sr:competitor:2702", "name"=>"AS Roma", "country"=>"Italy", "country_code"=>"ITA", "abbreviation"=>"ROM", "qualifier"=>"away"}]
+
+
+m = Sportradar::Api::Soccer::Match.new({"id"=>"sr:match:12090446"}, league_group: 'eu')
+res = m.get_summary
+res = m.get_lineups
+res = m.get_facts
+res = m.get_probabilities
+res = m.get_timeline

data/lib/sportradar/api/soccer/player.rb

@@ -1,86 +1,73 @@
 module Sportradar
   module Api
-    class Soccer::Player < Data
+    module Soccer
+      class Player < Data
 
-      attr_accessor :id, :first_name, :last_name, :country_code, :country, :reference_id, :full_first_name, :full_last_name, :position, :started, :jersey_number, :tactical_position, :tactical_order, :statistics, :preferred_foot, :birthdate, :height_in, :weight_lb, :height_cm, :weight_kg, :teams, :response, :rank, :total, :statistics, :last_modified
+        attr_reader :id, :league_group, :name, :type, :nationality, :country_code, :height, :weight, :jersey_number, :preferred_foot, :stats, :date_of_birth, :matches_played
+        alias :position :type
 
-      def initialize(data)
-        @response = data
-        @teams = parse_into_array(selector: response["team"], klass: Sportradar::Api::Soccer::Team)  if response["team"]
-        @teams = parse_into_array(selector: response["teams"]["team"], klass: Sportradar::Api::Soccer::Team)  if response["teams"] && response["teams"]["team"]
-        @id = data["id"]
-        @first_name = data["first_name"]
-        @last_name = data["last_name"]
-        @country_code = data["country_code"]
-        @country = data["country"]
-        @reference_id = data["reference_id"]
-        @full_first_name = data["full_first_name"]
-        @full_last_name = data["full_last_name"]
-        @position = data["position"] || primary_team.try(:position)
-        @started = data["started"]
-        @jersey_number = data["jersey_number"] || primary_team.try(:jersey_number)
-        @tactical_position = data["tactical_position"]
-        @tactical_order = data["tactical_order"]
-        @last_modified = data["last_modified"]
+        def initialize(data = {}, league_group: nil, **opts)
+          @response     = data
+          @id           = data['id'] if data['id']
+          @api          = opts[:api]
+          @league_group = league_group || data['league_group'] || @api&.league_group
 
-        # profile
-        @preferred_foot = data["preferred_foot"]
-        @birthdate = data["birthdate"]
-        @height_in = data["height_in"]
-        @weight_lb = data["weight_lb"]
-        @height_cm = data["height_cm"]
-        @weight_kg = data["weight_kg"]
-        @rank = data["rank"]
-        @total = OpenStruct.new data["total"] if data["total"]
-        @statistics = parse_into_array(selector:response["statistics"]["season"], klass: Sportradar::Api::Soccer::Season)  if response["statistics"] &&  response["statistics"]["season"]
+          update(data, **opts)
+        end
 
-      end
+        def update(data, **opts)
+          @id             = data['id']             if data['id']
+          @league_group = opts[:league_group] || data['league_group'] || @league_group
 
-      def name
-        [first_name, last_name].join(' ')
-      end
+          if data['player']
+            update(data['player'])
+          end
 
-      def full_name
-        full = [full_first_name, full_last_name].join(' ')
-        full == " " ? name : full
-      end
+          @name           = data['name']           if data['name']
+          @last_name      = data['last_name']      if data['last_name']
+          @first_name     = data['first_name']     if data['first_name']
+          @type           = data['type']           if data['type']
+          @nationality    = data['nationality']    if data['nationality']
+          @country_code   = data['country_code']   if data['country_code']
+          @height         = data['height']         if data['height']
+          @weight         = data['weight']         if data['weight']
+          @jersey_number  = data['jersey_number']  if data['jersey_number']
+          @preferred_foot = data['preferred_foot'] if data['preferred_foot']
+          @matches_played = data['matches_played'] if data['matches_played']
 
-      def position_name
-        positions = {"G" => "Goalie", "D" => "Defender", "M" => "Midfielder", "F" => "Forward", "" => "N/A"}
-        if position
-          positions[position]
-        elsif primary_team.present?
-          positions[primary_team.position]
-        end
-      end
+          @stats          = data['statistics']     if data['statistics']
 
-      def primary_team
-        if teams.count == 1
-          teams.first
-        else
-          teams.find {|team| team.name != team.country_code}
-        end if teams
-      end
+          @date_of_birth  = Date.parse(data['date_of_birth']) if data['date_of_birth']
+        end
 
+        def display_name
+          @name || [@first_name, @last_name].join(' ')
+        end
 
-      def tactical_position_name
-        tactical_positions = { "0" => "Unknown", "1" => "Goalkeeper", "2" => "Right Back", "3" => "Central Defender", "4" => "Left Back", "5" => "Right winger", "6" => "Central Midfielder", "7" => "Left Winger", "8" => "Forward" }
-        tactical_positions[tactical_position] if tactical_position
-      end
+        def api
+          @api || Sportradar::Api::Soccer::Api.new(league_group: @league_group)
+        end
 
-      def age
-        if birthdate.present?
-          now = Time.now.utc.to_date
-          dob = birthdate.to_date
-          now.year - dob.year - ((now.month > dob.month || (now.month == dob.month && now.day >= dob.day)) ? 0 : 1)
+        def path_base
+          "players/#{ id }"
         end
-      end
 
-      def height_ft
-        if height_in.present?
-          feet, inches = height_in.to_i.divmod(12)
-          "#{feet}' #{inches}\""
+        def path_profile
+          "#{ path_base }/profile"
         end
+        def get_profile
+          data = api.get_data(path_profile).to_h
+          ingest_profile(data)
+        end
+        def ingest_profile(data)
+          update(data)
+          data
+        end
+        def queue_profile
+          url, headers, options, timeout = api.get_request_info(path_profile)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_profile)}
+        end
+
       end
 
     end

data/lib/sportradar/api/soccer/season.rb

@@ -1,14 +1,65 @@
 module Sportradar
   module Api
-    class Soccer::Season < Data
-      attr_accessor :response, :year, :statistics
+    module Soccer
+      class Season < Data
+        attr_reader :id, :league_group, :name, :category, :current_season, :season_coverage_info, :tournament_id
 
-      def initialize(data)
-        @response = data
-        @year = data["year"]
-        @statistics = parse_into_array(selector: response["statistic"], klass: Sportradar::Api::Soccer::Statistic)  if response["statistic"]
-      end
+        def initialize(data = {}, league_group: nil, **opts)
+          @response     = data
+          @id           = data["id"]
+          @api          = opts[:api]
+          @league_group = league_group || data['league_group'] || @api&.league_group
+
+          update(data, **opts)
+        end
+
+        def update(data, **opts)
+          @league_group       = opts[:league_group] || data['league_group'] || @league_group
+          @id                 = data['id'] || data['season_id'] || @id
+          @current            = opts[:current] || @current
+          get_tournament_id(data, **opts)
+
+          @name               = data['name']                || @name
+          @start_date         = data['start_date']          || @start_date
+          @end_date           = data['end_date']            || @end_date
+          @year               = data['year']                || @year
+          @scheduled          = data['scheduled']           || @scheduled
+          @played             = data['played']              || @played
+          @max_coverage_level = data['max_coverage_level']  || @max_coverage_level
+          @max_covered        = data['max_covered']         || @max_covered
+          @min_coverage_level = data['min_coverage_level']  || @min_coverage_level
+        end
+
+        def get_tournament_id(data, **opts)
+          @tournament_id ||= if opts[:tournament]
+            opts[:tournament].id
+          elsif data['tournament_id']
+            data['tournament_id']
+          elsif data['tournament']
+            data.dig('tournament', 'id')
+          end
+        end
+
+        def current?
+          !!@current
+        end
 
+        def api
+          @api ||= Sportradar::Api::Soccer::Api.new(league_group: @league_group)
+        end
+
+      end
     end
   end
 end
+
+__END__
+"current_season"=>{"id"=>"sr:season:41988", "name"=>"Primeira Liga 17/18", "start_date"=>"2017-08-05", "end_date"=>"2018-05-31", "year"=>"17/18"}
+"season_coverage_info"=>{"season_id"=>"sr:season:41988", "scheduled"=>306, "played"=>72, "max_coverage_level"=>"gold", "max_covered"=>72, "min_coverage_level"=>"gold"}
+
+
+group = Sportradar::Api::Soccer::Group.new(league_group: 'eu')
+res = group.get_tournaments;
+tour = group.tournaments.sample
+tour.get_seasons
+tour

data/lib/sportradar/api/soccer/standing.rb

@@ -1,13 +1,50 @@
 module Sportradar
   module Api
-    class Soccer::Standing < Data
-      attr_accessor :response, :categories
+    module Soccer
+      class Standing < Data
+        attr_reader :league_group, :id, :type
 
-      def initialize(data)
-        @response = data
-        @categories = parse_into_array(selector: response["categories"]["category"], klass: Sportradar::Api::Soccer::Category)  if response["categories"] && response["categories"]["category"]
-      end
+        def initialize(data = {}, league_group: nil, **opts)
+          @response     = data
+          @id           = data["id"] || data['type']
+          @api          = opts[:api]
+          @league_group = league_group || data['league_group'] || @api&.league_group
+
+          @groups_hash = {}
+
+          update(data, **opts)
+        end
+
+        def update(data, **opts)
+          @type           = data['type']
+          @tie_break_rule = data['tie_break_rule'] if data['tie_break_rule']
+
+          if data['groups']
+            create_data(@groups_hash, data['groups'], klass: TeamGroup, api: api, identifier: 'name')
+          end
+        end
+
+        def groups(name = nil)
+          @groups_hash.values
+        end
 
+        def group(name = nil) # nil represents the complete team listing
+          @groups_hash[name]
+        end
+
+        def teams
+          @groups_hash.values.flat_map(&:teams)
+        end
+
+        def team(id)
+          @groups_hash.values.flat_map(&:teams).detect { |team| team.id == id }
+        end
+
+        def api
+          @api ||= Sportradar::Api::Soccer::Api.new(league_group: @league_group)
+        end
+
+      end
     end
   end
 end