jumbotron 0.1.1

data/app/services/jumbotron/services/canonical/resolve_current_lines_for_games.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class ResolveCurrentLinesForGames < CommandTower::Services::ApplicationService
+        GRAIN = %i[game_id bookmaker_id market outcome source].freeze
+
+        validate :game_ids, required: false
+
+        def call
+          ids = Array(game_ids).map(&:to_i).uniq
+          if ids.empty?
+            context.current_lines = []
+            context.current_lines_by_game_id = {}
+            return
+          end
+
+          lines = latest_observed(ids).map { |row| to_current_line(row) }
+          context.current_lines = lines
+          context.current_lines_by_game_id = lines.group_by(&:game_id)
+        end
+
+        private
+
+        def latest_observed(ids)
+          scope = LineObservation.where(game_id: ids, source: "observed")
+          observation_ids = scope.joins(latest_observed_at_join(scope)).group(*GRAIN).maximum(:id).values
+          return [] if observation_ids.empty?
+
+          LineObservation.where(id: observation_ids).includes(:bookmaker).to_a
+        end
+
+        def latest_observed_at_join(scope)
+          observations = LineObservation.arel_table
+          max_observed = scope.select(
+            *GRAIN,
+            observations[:observed_at].maximum.as("observed_at")
+          ).group(*GRAIN)
+
+          <<~SQL.squish
+            INNER JOIN (#{max_observed.to_sql}) latest
+              ON jumbotron_line_observations.game_id = latest.game_id
+             AND jumbotron_line_observations.bookmaker_id = latest.bookmaker_id
+             AND jumbotron_line_observations.market = latest.market
+             AND jumbotron_line_observations.outcome = latest.outcome
+             AND jumbotron_line_observations.source = latest.source
+             AND jumbotron_line_observations.observed_at = latest.observed_at
+          SQL
+        end
+
+        def to_current_line(row)
+          Jumbotron::Canonical::CurrentLine.new(
+            line_observation_id: row.id,
+            game_id: row.game_id,
+            bookmaker_id: row.bookmaker_id,
+            bookmaker_name: row.bookmaker.name,
+            market: row.market,
+            outcome: row.outcome,
+            line_value: row.line_value,
+            price_american: row.price_american,
+            observed_at: row.observed_at,
+            changed_at: row.changed_at
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/canonical/upsert_game.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      # Persists the Game row only. Callers supply resolved season/phase/venue.
+      class UpsertGame < CommandTower::Services::ApplicationService
+        MATERIAL_ATTRS = %i[
+          season_id
+          season_phase_id
+          schedule_group_id
+          scheduled_at
+          lifecycle
+          venue_id
+          neutral_site
+          progress_state
+          progress_segment_kind
+          progress_segment_number
+          progress_clock_mode
+        ].freeze
+
+        SILENT_ATTRS = %i[
+          progress_clock_seconds
+          progress_clock_display
+        ].freeze
+
+        validate :game_input, required: true
+        validate :league, required: true
+        validate :season, required: true
+        validate :season_phase, required: true
+        validate :schedule_group, required: false
+        validate :venue, required: false
+        validate :observed_at, required: true
+        validate :change_set, required: true
+
+        def call
+          game = find_game
+          context.game = resolve_game(game)
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+
+        private
+
+        def resolve_game(game)
+          if game
+            update_existing!(Game.lock.find(game.id))
+          else
+            create_new!
+          end
+        end
+
+        def find_game
+          game_input.provider_identities.each do |ref|
+            identity = ProviderIdentity.find_by(
+              provider: ref.provider,
+              object_namespace: ref.namespace,
+              provider_id: ref.id
+            )
+            return identity.target if identity&.target.is_a?(Game)
+          end
+          nil
+        end
+
+        def create_new!
+          game = Game.create!(create_attrs)
+          record_create_history!(game)
+          game
+        end
+
+        def create_attrs
+          {
+            league: league,
+            season: season,
+            season_phase: season_phase,
+            schedule_group: schedule_group,
+            venue: venue,
+            scheduled_at: game_input.scheduled_at,
+            lifecycle: game_input.lifecycle,
+            neutral_site: game_input.neutral_site.nil? ? false : game_input.neutral_site,
+            observed_at: observed_at,
+            changed_at: observed_at
+          }.merge(progress_column_values)
+        end
+
+        def record_create_history!(game)
+          change_set.record(subject: game, attribute: "lifecycle", previous: nil, new_value: game.lifecycle)
+          change_set.record(
+            subject: game,
+            attribute: "scheduled_at",
+            previous: nil,
+            new_value: game.scheduled_at&.iso8601
+          )
+          MATERIAL_ATTRS.grep(/\Aprogress_/).each do |key|
+            value = game.public_send(key)
+            next if value.nil?
+
+            change_set.record(subject: game, attribute: key.to_s, previous: nil, new_value: serialize(value))
+          end
+        end
+
+        def update_existing!(game)
+          attrs = {
+            season_id: season.id,
+            season_phase_id: season_phase.id,
+            schedule_group_id: schedule_group&.id,
+            scheduled_at: game_input.scheduled_at,
+            lifecycle: game_input.lifecycle
+          }
+          attrs[:venue_id] = venue&.id unless game_input.venue.nil?
+          attrs[:neutral_site] = game_input.neutral_site unless game_input.neutral_site.nil?
+          attrs.merge!(progress_column_values)
+
+          material = apply_material_attrs!(game, attrs)
+          apply_silent_attrs!(game, attrs)
+
+          game.observed_at = observed_at
+          game.changed_at = observed_at if material
+          game.save!
+          game
+        end
+
+        def apply_material_attrs!(game, attrs)
+          material = false
+          attrs.slice(*MATERIAL_ATTRS).each do |key, value|
+            current = game.public_send(key)
+            next if serialize(current) == serialize(value)
+
+            change_set.record(
+              subject: game,
+              attribute: key.to_s,
+              previous: serialize(current),
+              new_value: serialize(value)
+            )
+            game.public_send("#{key}=", value)
+            material = true
+          end
+          material
+        end
+
+        def apply_silent_attrs!(game, attrs)
+          attrs.slice(*SILENT_ATTRS).each do |key, value|
+            game.public_send("#{key}=", value)
+          end
+        end
+
+        def progress_column_values
+          progress = game_input.progress
+          if progress.nil?
+            {
+              progress_state: nil,
+              progress_segment_kind: nil,
+              progress_segment_number: nil,
+              progress_clock_mode: nil,
+              progress_clock_seconds: nil,
+              progress_clock_display: nil
+            }
+          else
+            clock = progress.clock
+            {
+              progress_state: progress.state,
+              progress_segment_kind: progress.segment.kind,
+              progress_segment_number: progress.segment.number,
+              progress_clock_mode: clock&.mode,
+              progress_clock_seconds: clock&.seconds,
+              progress_clock_display: clock&.display
+            }
+          end
+        end
+
+        def serialize(value)
+          case value
+          when Time, ActiveSupport::TimeWithZone
+            value.iso8601
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/canonical/upsert_game_participant.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class UpsertGameParticipant < CommandTower::Services::ApplicationService
+        validate :game, required: true
+        validate :participant_input, required: true
+        validate :observed_at, required: true
+        validate :change_set, required: true
+
+        def call
+          team_result = UpsertTeam.call(
+            team_input: Jumbotron::Canonical::TeamInput.new(
+              provider_identities: participant_input.provider_identities,
+              name: participant_input.team_name
+            ),
+            observed_at: observed_at,
+            change_set: change_set
+          )
+          unless team_result.success?
+            context.fail!(application_error: team_result.errors.first)
+            return
+          end
+
+          team = team_result.data[:team]
+          participant = game.game_participants.lock.find_by(team_id: team.id)
+          context.game_participant = resolve_participant(participant, team)
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+
+        private
+
+        def resolve_participant(participant, team)
+          if participant
+            update_existing!(participant)
+          else
+            create_new!(team)
+          end
+        end
+
+        def create_new!(team)
+          gp = game.game_participants.create!(
+            team: team,
+            role: participant_input.role,
+            score: participant_input.score,
+            result: participant_input.result,
+            observed_at: observed_at,
+            changed_at: observed_at
+          )
+          change_set.record(subject: gp, attribute: "role", previous: nil, new_value: gp.role)
+          change_set.record(subject: gp, attribute: "score", previous: nil, new_value: gp.score)
+          gp
+        end
+
+        def update_existing!(participant)
+          material = false
+          {
+            role: participant_input.role,
+            score: participant_input.score,
+            result: participant_input.result
+          }.each do |key, value|
+            current = participant.public_send(key)
+            next if current == value
+
+            change_set.record(
+              subject: participant,
+              attribute: key.to_s,
+              previous: current,
+              new_value: value
+            )
+            participant.public_send("#{key}=", value)
+            material = true
+          end
+          participant.observed_at = observed_at
+          participant.changed_at = observed_at if material
+          participant.save!
+          participant
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/canonical/upsert_team.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class UpsertTeam < CommandTower::Services::ApplicationService
+        validate :team_input, required: true
+        validate :observed_at, required: true
+        validate :change_set, required: true
+
+        def call
+          ref = team_input.provider_identities.first
+          identity = ProviderIdentity.find_by(
+            provider: ref.provider,
+            object_namespace: ref.namespace,
+            provider_id: ref.id
+          )
+
+          team = resolve_team(identity)
+
+          attach = AttachProviderIdentities.call(target: team, refs: team_input.provider_identities)
+          unless attach.success?
+            context.fail!(application_error: attach.errors.first)
+            return
+          end
+
+          context.team = team
+        rescue ActiveRecord::RecordNotUnique
+          context.team = recover_after_race!
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+
+        private
+
+        def resolve_team(identity)
+          if identity&.target.is_a?(Team)
+            update_existing!(identity.target_id)
+          else
+            create_new!
+          end
+        end
+
+        def update_existing!(team_id)
+          team = Team.lock.find(team_id)
+          if team.name != team_input.name
+            change_set.record(
+              subject: team,
+              attribute: "name",
+              previous: team.name,
+              new_value: team_input.name
+            )
+            team.name = team_input.name
+            team.changed_at = observed_at
+          end
+          team.observed_at = observed_at
+          team.save!
+          team
+        end
+
+        def create_new!
+          team = Team.create!(
+            name: team_input.name,
+            observed_at: observed_at,
+            changed_at: observed_at
+          )
+          change_set.record(subject: team, attribute: "name", previous: nil, new_value: team.name)
+          team
+        end
+
+        def recover_after_race!
+          ref = team_input.provider_identities.first
+          identity = ProviderIdentity.find_by!(
+            provider: ref.provider,
+            object_namespace: ref.namespace,
+            provider_id: ref.id
+          )
+          team = Team.lock.find(identity.target_id)
+          team.observed_at = observed_at
+          team.save!
+          team
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/canonical/upsert_venue.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class UpsertVenue < CommandTower::Services::ApplicationService
+        validate :venue_input, required: false
+        validate :observed_at, required: true
+        validate :change_set, required: true
+
+        def call
+          if venue_input.nil?
+            context.venue = nil
+            return
+          end
+
+          ref = venue_input.provider_identities.first
+          identity = ProviderIdentity.find_by(
+            provider: ref.provider,
+            object_namespace: ref.namespace,
+            provider_id: ref.id
+          )
+
+          venue = resolve_venue(identity)
+
+          attach = AttachProviderIdentities.call(target: venue, refs: venue_input.provider_identities)
+          unless attach.success?
+            context.fail!(application_error: attach.errors.first)
+            return
+          end
+
+          context.venue = venue
+        rescue ActiveRecord::RecordNotUnique
+          context.venue = recover_after_race!
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+
+        private
+
+        def resolve_venue(identity)
+          if identity&.target.is_a?(Venue)
+            update_existing!(identity.target_id)
+          else
+            create_new!
+          end
+        end
+
+        def update_existing!(venue_id)
+          venue = Venue.lock.find(venue_id)
+          if venue.name != venue_input.name
+            change_set.record(
+              subject: venue,
+              attribute: "name",
+              previous: venue.name,
+              new_value: venue_input.name
+            )
+            venue.name = venue_input.name
+            venue.changed_at = observed_at
+          end
+          venue.observed_at = observed_at
+          venue.save!
+          venue
+        end
+
+        def create_new!
+          venue = Venue.create!(
+            name: venue_input.name,
+            observed_at: observed_at,
+            changed_at: observed_at
+          )
+          change_set.record(subject: venue, attribute: "name", previous: nil, new_value: venue.name)
+          venue
+        end
+
+        def recover_after_race!
+          ref = venue_input.provider_identities.first
+          identity = ProviderIdentity.find_by!(
+            provider: ref.provider,
+            object_namespace: ref.namespace,
+            provider_id: ref.id
+          )
+          Venue.lock.find(identity.target_id)
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/public/assemble_public_game.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class AssemblePublicGame < CommandTower::Services::ApplicationService
+        validate :game, required: true
+        validate :includes, required: false
+        validate :current_lines, required: false
+        validate :consensus_lines, required: false
+
+        def call
+          context.public_game = build_game(game)
+        end
+
+        private
+
+        def build_game(record)
+          game_currents = Array(current_lines).select { |line| line.game_id == record.id }
+          game_consensus = Array(consensus_lines).select { |line| line.game_id == record.id }
+          Jumbotron::Public::Game.new(
+            id: record.id,
+            scheduled_at: record.scheduled_at,
+            lifecycle: record.lifecycle,
+            progress: build_progress(record),
+            neutral_site: record.neutral_site,
+            observed_at: record.observed_at,
+            changed_at: record.changed_at,
+            venue: build_venue(record.venue),
+            participants: record.game_participants.map { |participant| build_participant(participant) },
+            consensus_lines: map_consensus(game_consensus, game_currents),
+            current_lines: map_currents(game_currents)
+          )
+        end
+
+        def build_progress(record)
+          return if record.progress_state.blank?
+
+          Jumbotron::Public::GameProgress.new(
+            state: record.progress_state,
+            segment: Jumbotron::Public::GameSegment.new(
+              kind: record.progress_segment_kind,
+              number: record.progress_segment_number
+            ),
+            clock: build_clock(record)
+          )
+        end
+
+        def build_clock(record)
+          return if record.progress_clock_mode.nil? &&
+                    record.progress_clock_seconds.nil? &&
+                    record.progress_clock_display.nil?
+
+          Jumbotron::Public::GameClock.new(
+            mode: record.progress_clock_mode,
+            seconds: record.progress_clock_seconds,
+            display: record.progress_clock_display
+          )
+        end
+
+        def build_venue(venue)
+          return if venue.nil?
+
+          Jumbotron::Public::Venue.new(id: venue.id, name: venue.name)
+        end
+
+        def build_participant(participant)
+          Jumbotron::Public::Participant.new(
+            role: participant.role,
+            score: participant.score,
+            result: participant.result,
+            team: Jumbotron::Public::Team.new(id: participant.team.id, name: participant.team.name)
+          )
+        end
+
+        def map_currents(lines)
+          return [] unless Array(includes).include?(:current_lines)
+
+          lines.map do |line|
+            Jumbotron::Public::CurrentLine.new(
+              game_id: line.game_id,
+              bookmaker_id: line.bookmaker_id,
+              bookmaker_name: line.bookmaker_name,
+              market: line.market,
+              outcome: line.outcome,
+              line_value: line.line_value,
+              price_american: line.price_american,
+              observed_at: line.observed_at,
+              changed_at: line.changed_at
+            )
+          end
+        end
+
+        def map_consensus(lines, currents)
+          return [] unless consensus_requested?
+
+          with_constituents = Array(includes).include?(:consensus_constituents)
+          lines.map do |line|
+            Jumbotron::Public::ConsensusLine.new(
+              game_id: line.game_id,
+              market: line.market,
+              outcome: line.outcome,
+              line_value: line.line_value,
+              constituent_count: line.constituent_count,
+              observed_at: consensus_observed_at(line, currents),
+              constituents: with_constituents ? map_constituents(line) : []
+            )
+          end
+        end
+
+        def consensus_requested?
+          includes = Array(self.includes)
+          includes.include?(:consensus) || includes.include?(:consensus_constituents)
+        end
+
+        def consensus_observed_at(line, currents)
+          currents.select { |current| current.market == line.market && current.outcome == line.outcome }
+                  .map(&:observed_at)
+                  .compact
+                  .max
+        end
+
+        def map_constituents(line)
+          Array(line.constituents).map do |constituent|
+            Jumbotron::Public::ConsensusConstituent.new(bookmaker_id: constituent.bookmaker_id)
+          end
+        end
+      end
+    end
+  end
+end