ahl_scraper 0.1.1

data/lib/ahl_scraper/resources/team_list_item.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  class TeamListItem < Resource
+    attr_reader :season_id
+
+    def initialize(raw_data, season_id)
+      @raw_data = raw_data
+      @season_id = season_id
+    end
+
+    def name
+      @name ||= @raw_data[:row][:name]
+    end
+
+    def id
+      @id ||= @raw_data[:prop][:team_code][:teamLink].to_i
+    end
+  end
+end

data/lib/ahl_scraper/roster_players.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  module RosterPlayers
+    class << self
+      def retrieve_all(team_id, season_id)
+        TeamRosterDataFetcher.new(team_id, season_id).call&.map { |player| RosterPlayer.new(player, team_id, season_id) }
+      end
+    end
+  end
+end

data/lib/ahl_scraper/seasons.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "ahl_scraper/services/seasons/teams_service"
+
+require "ahl_scraper/resources/seasons/team"
+
+module AhlScraper
+  module Seasons
+    @season_data = nil
+
+    class << self
+      def list
+        @season_data ||= SeasonDataFetcher.new.call&.map { |season_data| SeasonListItem.new(season_data) }
+        @season_data
+      end
+
+      def retrieve(season_id)
+        @season_data ||= SeasonDataFetcher.new.call&.map { |season_data| SeasonListItem.new(season_data) }
+        season = @season_data.find { |s| season_id.to_i == s.id }
+        Season.new(season)
+      end
+
+      def retrieve_all
+        @season_data ||= SeasonDataFetcher.new.call
+        @season_data.map do |season|
+          Season.new(season)
+        end
+      end
+    end
+  end
+end

data/lib/ahl_scraper/services/games/create_skaters_service.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  module Games
+    class CreateSkatersService
+      def initialize(skater_data, goal_data, penalty_data, shootout_data, penalty_shot_data, opts)
+        @skater_data = skater_data
+        @goal_data = goal_data
+        @penalty_data = penalty_data
+        @shootout_data = shootout_data
+        @penalty_shot_data = penalty_shot_data
+        @opts = opts
+      end
+
+      def call
+        scoring_statlines = ScoringStatlinesService.new(team_goals, skater_ids, @opts).call
+        on_ice_statlines = OnIceStatlinesService.new(@goal_data, @opts[:team_id], skater_ids).call
+        penalty_statlines = PenaltyStatlinesService.new(@penalty_data, @opts[:team_id], skater_ids).call
+        penalty_shot_statlines = PenaltyShotStatlinesService.new(@penalty_shot_data, @opts[:team_id], skater_ids).call
+        shootout_statlines = ShootoutStatlinesService.new(@shootout_data, @opts[:team_id], skater_ids).call
+
+        skaters.map do |s|
+          id_key = s[:id].to_s
+          Skater.new(
+            s,
+            {
+              **@opts,
+              scoring_statline: scoring_statlines[id_key],
+              on_ice_statline: on_ice_statlines[id_key],
+              penalty_statline: penalty_statlines[id_key],
+              penalty_shot_statline: penalty_shot_statlines[id_key],
+              shootout_statline: shootout_statlines[id_key],
+            }
+          )
+        end
+      end
+
+      private
+
+      def team_goals
+        @goal_data.filter { |g| g[:team][:id] == @opts[:team_id] }
+      end
+
+      def skater_ids
+        @skater_ids ||= @skater_data.map { |skater| skater[:info][:id] }
+      end
+
+      def skaters
+        @skater_data.map do |s|
+          {
+            id: s[:info][:id],
+            first_name: s[:info][:firstName],
+            last_name: s[:info][:lastName],
+            position: s[:info][:position],
+            birthdate: s[:info][:birthDate],
+            number: s[:info][:jerseyNumber],
+            starting: s[:starting] == 1,
+            captaincy: %w[A C].include?(s[:status]) ? s[:status] : nil,
+            home_team: @opts[:home_team],
+            team_id: @opts[:team_id],
+            team_abbreviation: @opts[:team_abbreviation],
+            faceoff_attempts: s[:stats][:faceoffAttempts],
+            faceoff_wins: s[:stats][:faceoffWins],
+            hits: s[:stats][:hits],
+            penalty_minutes: s[:stats][:penaltyMinutes],
+            sog_as: s[:stats][:shots],
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ahl_scraper/services/games/on_ice_statlines_service.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  module Games
+    class OnIceStatlinesService
+      def initialize(goal_data, team_id, skater_ids)
+        @goal_data = goal_data
+        @team_id = team_id
+        @skater_ids = skater_ids
+      end
+
+      def call
+        @goal_data.each do |goal|
+          next if goal[:properties][:isPenaltyShot] == "1"
+
+          goal_status = goal[:team][:id] == @team_id ? "gf" : "ga"
+          on_scoring_team = goal[:team][:id] == @team_id
+          plus_player_ids = goal[:plus_players].map { |pl| pl[:id].to_s }
+          minus_player_ids = goal[:minus_players].map { |pl| pl[:id].to_s }
+          skater_ids = on_scoring_team ? plus_player_ids : minus_player_ids
+          opposing_skater_ids = on_scoring_team ? minus_player_ids : plus_player_ids
+          goal_situation = find_goal_situation(goal, on_scoring_team)
+          goal_player_counts = find_goal_player_counts(skater_ids, opposing_skater_ids, on_scoring_team)
+
+          skater_ids.map(&:to_s).each do |skater_id|
+            on_ice_statlines[skater_id] ||= blank_statline
+            on_ice_statlines[skater_id]["#{goal_status}_as".to_sym] += 1
+            on_ice_statlines[skater_id]["#{goal_status}_#{goal_situation}".to_sym] += 1
+            next unless opposing_skater_ids.length >= 3 && skater_ids.length >= 3 && opposing_skater_ids.length <= 6 && skater_ids.length <= 6
+
+            on_ice_statlines[skater_id]["#{goal_status}_#{goal_player_counts}".to_sym] += 1
+          end
+        end
+
+        on_ice_statlines
+      end
+
+      private
+
+      def on_ice_statlines
+        @on_ice_statlines ||= @skater_ids.map { |s_id| [s_id.to_s, blank_statline] }.to_h
+      end
+
+      def find_goal_player_counts(skater_ids, opposing_skater_ids, on_scoring_team)
+        on_scoring_team ? "#{skater_ids.length}v#{opposing_skater_ids.length}" : "#{opposing_skater_ids.length}v#{skater_ids.length}"
+      end
+
+      def find_goal_situation(goal, on_scoring_team)
+        return "pp" if (goal[:properties][:isPowerPlay] == "1" && on_scoring_team) || (goal[:properties][:isShortHanded] == "1" && !on_scoring_team)
+
+        return "sh" if goal[:properties][:isShortHanded] == "1" && on_scoring_team || (goal[:properties][:isPowerPlay] == "1" && !on_scoring_team)
+
+        return "en" if goal[:properties][:isEmptyNet] == "1" && on_scoring_team
+
+        return "ex" if goal[:properties][:isEmptyNet] == "1" && !on_scoring_team
+
+        if goal[:plus_players].length == 6 ||
+           (goal[:properties][:isPowerPlay] == "1" && goal[:plus_players].length == goal[:minus_players].length) ||
+           (goal[:properties][:isShortHanded] == "1" && goal[:plus_players].length == goal[:minus_players].length)
+
+          return on_scoring_team ? "ex" : "en"
+        end
+
+        "ev"
+      end
+
+      def blank_statline
+        {
+          gf_as: 0,
+          gf_ev: 0,
+          gf_pp: 0,
+          gf_sh: 0,
+          gf_ex: 0,
+          gf_en: 0,
+          gf_6v6: 0,
+          gf_6v5: 0,
+          gf_6v4: 0,
+          gf_6v3: 0,
+          gf_5v6: 0,
+          gf_5v5: 0,
+          gf_5v4: 0,
+          gf_5v3: 0,
+          gf_4v6: 0,
+          gf_4v5: 0,
+          gf_4v4: 0,
+          gf_4v3: 0,
+          gf_3v6: 0,
+          gf_3v5: 0,
+          gf_3v4: 0,
+          gf_3v3: 0,
+          ga_as: 0,
+          ga_ev: 0,
+          ga_pp: 0,
+          ga_sh: 0,
+          ga_ex: 0,
+          ga_en: 0,
+          ga_6v6: 0,
+          ga_6v5: 0,
+          ga_6v4: 0,
+          ga_6v3: 0,
+          ga_5v6: 0,
+          ga_5v5: 0,
+          ga_5v4: 0,
+          ga_5v3: 0,
+          ga_4v6: 0,
+          ga_4v5: 0,
+          ga_4v4: 0,
+          ga_4v3: 0,
+          ga_3v6: 0,
+          ga_3v5: 0,
+          ga_3v4: 0,
+          ga_3v3: 0,
+        }
+      end
+    end
+  end
+end

data/lib/ahl_scraper/services/games/penalty_shot_statlines_service.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  module Games
+    class PenaltyShotStatlinesService
+      def initialize(penalty_shot_data, team_id, skater_ids)
+        @penalty_shot_data = penalty_shot_data
+        @team_id = team_id
+        @skater_ids = skater_ids
+      end
+
+      def call
+        @penalty_shot_data.each do |penalty_shot|
+          skater_id = penalty_shot[:shooter][:id].to_s
+          penalty_shot_statlines[skater_id] ||= blank_statline
+
+          penalty_shot_statlines[skater_id][:attempts] += 1
+          penalty_shot_statlines[skater_id][:goals] += 1 if penalty_shot[:isGoal]
+        end
+
+        penalty_shot_statlines
+      end
+
+      private
+
+      def penalty_shot_statlines
+        @penalty_shot_statlines ||= @skater_ids.map { |s_id| [s_id.to_s, blank_statline] }.to_h
+      end
+
+      def blank_statline
+        {
+          attempts: 0,
+          goals: 0,
+        }
+      end
+    end
+  end
+end

data/lib/ahl_scraper/services/games/penalty_shots_service.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  module Games
+    class PenaltyShotsService
+      attr_reader :penalty_shot_data
+
+      def initialize(penalty_shot_data)
+        @penalty_shot_data = penalty_shot_data
+      end
+
+      def call
+        ordered_penalty_shots.map.with_index { |ps, i| PenaltyShot.new(ps, { number: i + 1 }) }
+      end
+
+      private
+
+      def ordered_penalty_shots
+        @ordered_penalty_shots ||= penalty_shot_data.sort do |a, b|
+          [a[:period][:id].to_i, convert_time(a[:time])] <=> [b[:period][:id].to_i, convert_time(b[:time])]
+        end
+      end
+
+      def convert_time(game_time)
+        time = game_time.split(":")
+        time[0].to_i * 60 + time[1].to_i
+      end
+    end
+  end
+end

data/lib/ahl_scraper/services/games/penalty_statlines_service.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  module Games
+    class PenaltyStatlinesService
+      def initialize(penalty_data, team_id, skater_ids)
+        @penalty_data = penalty_data
+        @team_id = team_id
+        @skater_ids = skater_ids
+      end
+
+      def call
+        @penalty_data.each do |penalty|
+          next unless penalty[:takenBy]
+
+          skater_id = penalty_statlines[penalty[:takenBy][:id].to_s] ? penalty[:takenBy][:id].to_s : false
+          next unless skater_id
+
+          penalty_statlines[skater_id][penalty_type(penalty)] += 1
+          penalty_statlines[skater_id][:penalty_minutes] += penalty[:minutes].to_i
+        end
+
+        penalty_statlines
+      end
+
+      private
+
+      def penalty_statlines
+        @penalty_statlines ||= @skater_ids.map { |s_id| [s_id.to_s, blank_statline] }.to_h
+      end
+
+      def blank_statline
+        {
+          penalty_minutes: 0,
+          minors: 0,
+          double_minors: 0,
+          majors: 0,
+          fights: 0,
+          misconducts: 0,
+          game_misconducts: 0,
+        }
+      end
+
+      def penalty_type(penalty)
+        case penalty[:description]
+        when /double minor/i
+          :double_minors
+        when /major/i
+          :majors
+        when /fighting/i
+          :fights
+        when /game misconduct/i
+          :game_misconducts
+        when /misconduct/i
+          :misconducts
+        else
+          :minors
+        end
+      end
+    end
+  end
+end

data/lib/ahl_scraper/services/games/scoring_statlines_service.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module AhlScraper
+  module Games
+    class ScoringStatlinesService
+      def initialize(goal_data, skater_ids, opts = {})
+        @goal_data = goal_data
+        @skater_ids = skater_ids
+        @opts = opts
+      end
+
+      def call
+        @goal_data.each do |goal|
+          plus_player_count = goal[:plus_players].length
+          minus_player_count = goal[:minus_players].length
+          goalscorer_id = scoring_statlines[goal[:scoredBy][:id].to_s] ? goal[:scoredBy][:id].to_s : false # Make sure goal does not belong to goalie
+          a1_id = goal[:assists][0]&.dig(:id) && scoring_statlines[goal[:assists][0]&.dig(:id).to_s] ? goal[:assists][0]&.dig(:id).to_s : false # Make sure assist exists and does not belong to goalie
+          a2_id = goal[:assists][1]&.dig(:id) && scoring_statlines[goal[:assists][1]&.dig(:id).to_s] ? goal[:assists][1]&.dig(:id).to_s : false # Make sure assist exists and does not belong to goalie
+
+          add_points(goalscorer_id, a1_id, a2_id, "as")
+          if goal[:properties][:isPenaltyShot].to_i.positive?
+            scoring_statlines[goalscorer_id][:goals_ps] += 1
+          elsif extra_skater?(goal, plus_player_count, minus_player_count)
+            add_points(goalscorer_id, a1_id, a2_id, "ex")
+          elsif goal[:properties][:isEmptyNet].to_i.positive?
+            add_points(goalscorer_id, a1_id, a2_id, "en")
+          elsif goal[:properties][:isPowerPlay].to_i.positive?
+            add_points(goalscorer_id, a1_id, a2_id, "pp")
+          elsif goal[:properties][:isShortHanded].to_i.positive?
+            add_points(goalscorer_id, a1_id, a2_id, "sh")
+          elsif plus_player_count == minus_player_count
+            add_points(goalscorer_id, a1_id, a2_id, "ev")
+            add_points(goalscorer_id, a1_id, a2_id, "5v5") if plus_player_count == 5 && minus_player_count == 5
+          end
+        end
+
+        scoring_statlines
+      end
+
+      private
+
+      def scoring_statlines
+        @scoring_statlines ||= @skater_ids.map { |s_id| [s_id.to_s, blank_statline] }.to_h
+      end
+
+      def blank_statline
+        {
+          goals_as: 0,
+          a1_as: 0,
+          a2_as: 0,
+          points_as: 0,
+          primary_points_as: 0,
+          goals_ps: 0,
+          primary_points_ps: 0,
+          goals_ev: 0,
+          a1_ev: 0,
+          a2_ev: 0,
+          points_ev: 0,
+          primary_points_ev: 0,
+          goals_5v5: 0,
+          a1_5v5: 0,
+          a2_5v5: 0,
+          points_5v5: 0,
+          primary_points_5v5: 0,
+          goals_pp: 0,
+          a1_pp: 0,
+          a2_pp: 0,
+          points_pp: 0,
+          primary_points_pp: 0,
+          goals_sh: 0,
+          a1_sh: 0,
+          a2_sh: 0,
+          points_sh: 0,
+          primary_points_sh: 0,
+          goals_ex: 0,
+          a1_ex: 0,
+          a2_ex: 0,
+          points_ex: 0,
+          primary_points_ex: 0,
+          goals_en: 0,
+          a1_en: 0,
+          a2_en: 0,
+          points_en: 0,
+          primary_points_en: 0,
+        }
+      end
+
+      def add_points(goalscorer_id, a1_id, a2_id, situation)
+        if goalscorer_id
+          scoring_statlines[goalscorer_id]["goals_#{situation}".to_sym] += 1
+          scoring_statlines[goalscorer_id]["primary_points_#{situation}".to_sym] += 1
+        end
+        if a1_id
+          scoring_statlines[a1_id]["a1_#{situation}".to_sym] += 1
+          scoring_statlines[a1_id]["primary_points_#{situation}".to_sym] += 1
+        end
+        scoring_statlines[a2_id]["a2_#{situation}".to_sym] += 1 if a2_id
+
+        scoring_statlines[goalscorer_id]["points_#{situation}".to_sym] += 1 if goalscorer_id
+        scoring_statlines[a1_id]["points_#{situation}".to_sym] += 1 if a1_id
+        scoring_statlines[a2_id]["points_#{situation}".to_sym] += 1 if a2_id
+      end
+
+      def extra_skater?(goal, scoring_team_player_count, defending_team_skater_count)
+        return true if scoring_team_player_count == 6
+
+        if (goal[:isPowerPlay].to_i.positive? || goal[:isShortHanded].to_i.positive?) && scoring_team_player_count == defending_team_skater_count
+          return true
+        end
+
+        false
+      end
+    end
+  end
+end