jumbotron 0.1.7 → 0.2.0

data/app/providers/jumbotron/providers/sandbox/resources/competition_odds.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Providers
+    module Sandbox
+      module Resources
+        class CompetitionOdds
+          def self.acquire(adapter:, **query)
+            return invalid_adapter unless adapter.provider == "sandbox"
+
+            CommandTower::Clients::ClientResult.success(output: query.symbolize_keys)
+          end
+
+          def self.invalid_adapter
+            CommandTower::Clients::ClientResult.failure(
+              error: ArgumentError.new("sandbox provider requires a sandbox adapter")
+            )
+          end
+          private_class_method :invalid_adapter
+        end
+      end
+    end
+  end
+end

data/app/providers/jumbotron/providers/sandbox/resources/projection.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Providers
+    module Sandbox
+      module Resources
+        module Projection
+          module_function
+
+          def acquire(adapter:, **projection)
+            unless adapter.provider.to_s == "sandbox"
+              return CommandTower::Clients::ClientResult.failure(
+                error: ArgumentError.new("sandbox projection requires sandbox adapter")
+              )
+            end
+
+            CommandTower::Clients::ClientResult.success(output: projection)
+          end
+        end
+      end
+    end
+  end
+end

data/app/providers/jumbotron/providers/sandbox/resources/scoreboard.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Providers
+    module Sandbox
+      module Resources
+        class Scoreboard
+          def self.acquire(adapter:, **query)
+            return invalid_adapter unless adapter.provider == "sandbox"
+
+            CommandTower::Clients::ClientResult.success(output: query.symbolize_keys)
+          end
+
+          def self.invalid_adapter
+            CommandTower::Clients::ClientResult.failure(
+              error: ArgumentError.new("sandbox provider requires a sandbox adapter")
+            )
+          end
+          private_class_method :invalid_adapter
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/adapters/execute_line_acquisition_scope.rb

@@ -6,6 +6,7 @@ module Jumbotron
       class ExecuteLineAcquisitionScope < CommandTower::Services::ApplicationService
         validate :adapter, required: true
         validate :acquisition, is_a: Hash, required: true
+        validate :observed_at, required: false
 
         def call
           if adapter.provider_cooling_down?
@@ -43,7 +44,7 @@ module Jumbotron
 
           ingest = adapter.translate_line_odds(
             provider_result.output,
-            observed_at: Time.current,
+            observed_at: observed_at || Time.current,
             acquisition: acquisition
           )
           persisted = Canonical::PersistLineObservations.call(ingest: ingest)

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class UpsertGameGraph < CommandTower::Services::ApplicationService
+        validate :game_input, required: true
+        validate :league, required: true
+        validate :observed_at, required: true
+        validate :change_set, required: true
+
+        def call
+          season = resolve(EnsureSeason.call(league: league, year: game_input.season_year), :season)
+          return if season.nil?
+
+          phase = resolve(
+            EnsureSeasonPhase.call(season: season, phase_key: game_input.season_phase_key),
+            :season_phase
+          )
+          return if phase.nil?
+
+          group = resolve_group(season, phase)
+          return if context.failure?
+
+          venue = resolve(
+            UpsertVenue.call(
+              venue_input: game_input.venue,
+              observed_at: observed_at,
+              change_set: change_set
+            ),
+            :venue,
+            allow_nil: true
+          )
+          return if context.failure?
+
+          game = upsert_game(season, phase, group, venue)
+          return if game.nil?
+          return unless attach_identities?(game)
+          return unless upsert_participants?(game)
+
+          context.game = game
+        end
+
+        private
+
+        def resolve_group(season, phase)
+          resolve(
+            EnsureScheduleGroup.call(
+              season: season,
+              season_phase: phase,
+              schedule_group_input: game_input.schedule_group
+            ),
+            :schedule_group,
+            allow_nil: true
+          )
+        end
+
+        def upsert_game(season, phase, group, venue)
+          resolve(
+            UpsertGame.call(
+              game_input: game_input,
+              league: league,
+              season: season,
+              season_phase: phase,
+              schedule_group: group,
+              venue: venue,
+              observed_at: observed_at,
+              change_set: change_set
+            ),
+            :game
+          )
+        end
+
+        def attach_identities?(game)
+          result = AttachProviderIdentities.call(target: game, refs: game_input.provider_identities)
+          return true if result.success?
+
+          fail_from(result)
+          false
+        end
+
+        def upsert_participants?(game)
+          game_input.participants.each do |participant_input|
+            result = UpsertGameParticipant.call(
+              game: game,
+              participant_input: participant_input,
+              observed_at: observed_at,
+              change_set: change_set,
+              preserve_existing_team: sandbox_game_input?
+            )
+            unless result.success?
+              fail_from(result)
+              return false
+            end
+          end
+          true
+        end
+
+        def sandbox_game_input?
+          game_input.provider_identities.any? { |identity| identity.provider == "sandbox" }
+        end
+
+        def resolve(result, key, allow_nil: false)
+          unless result.success?
+            fail_from(result)
+            return
+          end
+
+          value = result.data[key]
+          return value if allow_nil || !value.nil?
+
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: "#{key} was not resolved" }
+            )
+          )
+          nil
+        end
+
+        def fail_from(result)
+          context.fail!(application_error: Array(result.errors).first)
+        end
+      end
+    end
+  end
+end

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

@@ -8,9 +8,11 @@ module Jumbotron
         validate :participant_input, required: true
         validate :observed_at, required: true
         validate :change_set, required: true
+        validate :preserve_existing_team, required: false
 
         def call
-          team_result = UpsertTeam.call(
+          team = existing_team if preserve_existing_team
+          team_result = team || UpsertTeam.call(
             team_input: Jumbotron::Canonical::TeamInput.new(
               provider_identities: participant_input.provider_identities,
               name: participant_input.team_name,
@@ -20,12 +22,20 @@ module Jumbotron
             observed_at: observed_at,
             change_set: change_set
           )
-          unless team_result.success?
+          unless team
+            unless team_result.success?
+              context.fail!(application_error: team_result.errors.first)
+              return
+            end
+
+            team = team_result.data[:team]
+          end
+
+          if team.nil?
             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
@@ -38,6 +48,16 @@ module Jumbotron
 
         private
 
+        def existing_team
+          ref = participant_input.provider_identities.first
+          identity = Jumbotron::ProviderIdentity.find_by(
+            provider: ref.provider,
+            object_namespace: ref.namespace,
+            provider_id: ref.id
+          )
+          identity&.target if identity&.target.is_a?(Jumbotron::Team)
+        end
+
         def resolve_participant(participant, team)
           if participant
             update_existing!(participant)

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class AssembleSandboxProjection < CommandTower::Services::ApplicationService
+        validate :projection, required: true
+
+        def call
+          context.public_projection = Jumbotron::Public::SandboxProjection.new(
+            name: projection.name,
+            source: selector(projection.source_season, projection.source_anchor_phase.name),
+            sandbox: selector(projection.sandbox_season, projection.source_anchor_phase.name)
+          )
+        end
+
+        private
+
+        def selector(season, phase_name)
+          Jumbotron::Public::SandboxScheduleSelector.new(
+            sport: season.league.sport.name,
+            league: season.league.name,
+            season: season.name,
+            season_phase: phase_name
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class AssembleSandboxProjectionReset < CommandTower::Services::ApplicationService
+        validate :projection, required: true
+        validate :snapshot, required: true
+        validate :counts, required: true
+        validate :reset_at, required: true
+
+        def call
+          context.public_reset = Jumbotron::Public::SandboxProjectionReset.new(
+            projection: projection_identity,
+            source_anchor_date: snapshot.source_anchor_date,
+            target_anchor_date: snapshot.target_anchor_date,
+            date_shift_days: snapshot.date_shift_days,
+            projected_game_count: snapshot.games.count,
+            added_game_count: counts.fetch(:added),
+            updated_game_count: counts.fetch(:updated),
+            removed_game_count: counts.fetch(:removed),
+            start_week_game_count: counts.fetch(:start_week),
+            naturally_locked_game_count: counts.fetch(:naturally_locked),
+            reset_at: reset_at
+          )
+        end
+
+        private
+
+        def projection_identity
+          Jumbotron::Public::SandboxProjection.new(
+            name: projection.name,
+            source: selector(projection.source_season, projection.source_anchor_phase.name),
+            sandbox: selector(projection.sandbox_season, projection.source_anchor_phase.name)
+          )
+        end
+
+        def selector(season, phase_name)
+          Jumbotron::Public::SandboxScheduleSelector.new(
+            sport: season.league.sport.name,
+            league: season.league.name,
+            season: season.name,
+            season_phase: phase_name
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/jumbotron/services/sandbox/build_source_snapshot.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+# This service validates and snapshots the complete source projection atomically.
+# rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength
+module Jumbotron
+  module Services
+    module Sandbox
+      class BuildSourceSnapshot < CommandTower::Services::ApplicationService
+        validate :projection, required: true
+        validate :start_week, required: true
+        validate :anchor_day, required: true
+        validate :now, required: true
+
+        def call
+          source_games = load_source_games
+          return if source_games.nil?
+
+          calendar = resolve_calendar(source_games)
+          return if calendar.nil?
+
+          raw_games = source_games.map { |game| raw_game(game) }
+          return if context.failure?
+
+          fingerprint = fingerprint_for(raw_games, calendar)
+          projected_games = raw_games.map { |raw| projected_game(raw, calendar, fingerprint) }
+          return if context.failure?
+
+          context.snapshot = Jumbotron::SandboxProjectionData::Snapshot.new(
+            games: projected_games,
+            source_anchor_date: calendar.fetch(:source_anchor_date),
+            target_anchor_date: calendar.fetch(:target_anchor_date),
+            date_shift_days: calendar.fetch(:date_shift_days),
+            fingerprint: fingerprint,
+            start_week: start_week
+          )
+        end
+
+        private
+
+        def load_source_games
+          games = projection.source_season.games.includes(
+            :schedule_group,
+            :season_phase,
+            game_participants: { team: :provider_identities }
+          ).order(:scheduled_at, :id).to_a
+          return games if games.present? && games.all? { |game| complete_game?(game) }
+
+          reject("sandbox_projection_incomplete", "source season contains incomplete game structure")
+          nil
+        end
+
+        def complete_game?(game)
+          game.scheduled_at.present? &&
+            game.schedule_group&.kind == "week" &&
+            game.schedule_group.number.present? &&
+            game.season_phase.present? &&
+            %w[home away].all? { |role| participant(game, role).present? }
+        end
+
+        def resolve_calendar(games)
+          group = anchor_groups.one? ? anchor_groups.first : nil
+          return reject_calendar("source_week_not_found", "start week is missing or ambiguous") if group.nil?
+
+          group_games = games.select { |game| game.schedule_group_id == group.id }
+          return reject_calendar("source_week_not_found", "start week has no games") if group_games.empty?
+          return reject_calendar("sandbox_period_overlap", "source week windows overlap") unless non_overlapping?(games)
+
+          zone = ActiveSupport::TimeZone[projection.calendar_time_zone]
+          dates = group_games.map { |game| game.scheduled_at.in_time_zone(zone).to_date }
+          first_date = dates.min
+          last_date = dates.max
+          span = (last_date - first_date).to_i + 1
+          return reject_calendar("anchor_day_out_of_range", "anchor day exceeds source week span") if anchor_day > span
+
+          source_anchor = first_date + (anchor_day - 1)
+          target_anchor = now.in_time_zone(zone).to_date
+          {
+            zone: zone,
+            source_anchor_date: source_anchor,
+            target_anchor_date: target_anchor,
+            date_shift_days: (target_anchor - source_anchor).to_i
+          }
+        end
+
+        def anchor_groups
+          projection.source_anchor_phase.schedule_groups.where(
+            kind: "week",
+            number: start_week
+          ).to_a
+        end
+
+        def non_overlapping?(games)
+          windows = games.group_by(&:schedule_group_id).values.map do |members|
+            times = members.map(&:scheduled_at)
+            times.minmax
+          end.sort_by(&:first)
+          windows.each_cons(2).all? { |left, right| left.last < right.first }
+        end
+
+        def raw_game(game)
+          source_spread, source_total = source_consensus(game)
+          {
+            game: game,
+            source_spread: source_spread,
+            source_total: source_total,
+            home: team_data(participant(game, "home").team),
+            away: team_data(participant(game, "away").team)
+          }
+        rescue ArgumentError => e
+          reject("sandbox_projection_incomplete", e.message)
+          nil
+        end
+
+        def source_consensus(game)
+          result = Jumbotron::Services::Canonical::DeriveConsensusLine.call(game: game)
+          return [nil, nil] unless result.success?
+
+          lines = Array(result.data[:consensus_lines])
+          spread = lines.find { |line| line.market == "spread" && line.outcome == "home" }
+          total = lines.find { |line| line.market == "total" && line.outcome == "over" }
+          [spread&.line_value, total&.line_value]
+        end
+
+        def participant(game, role)
+          game.game_participants.find { |row| row.role == role }
+        end
+
+        def team_data(team)
+          identity = team.provider_identities.find do |candidate|
+            candidate.provider == "espn" && candidate.object_namespace == "team"
+          end
+          raise ArgumentError, "source team is missing ESPN identity" if identity.nil?
+
+          Jumbotron::SandboxProjectionData::Team.new(
+            provider_id: identity.provider_id,
+            name: team.name,
+            nickname: team.nickname,
+            abbreviation: team.abbreviation
+          )
+        end
+
+        def fingerprint_for(raw_games, calendar)
+          facts = raw_games.compact.map do |raw|
+            game = raw.fetch(:game)
+            [
+              game.id,
+              game.scheduled_at.iso8601,
+              game.season_phase.name,
+              game.schedule_group.number,
+              raw[:source_spread]&.to_s,
+              raw[:source_total]&.to_s
+            ]
+          end
+          Digest::SHA256.hexdigest(
+            JSON.generate(
+              version: 1,
+              projection: projection.name,
+              start_week: start_week,
+              anchor_day: anchor_day,
+              now: now.iso8601,
+              shift: calendar.fetch(:date_shift_days),
+              games: facts
+            )
+          )
+        end
+
+        def projected_game(raw, calendar, fingerprint)
+          game = raw.fetch(:game)
+          line = Jumbotron::Services::Sandbox::SelectLineBasis.call(
+            source_game_id: game.id,
+            reset_fingerprint: fingerprint,
+            source_spread: raw[:source_spread],
+            source_total: raw[:source_total]
+          )
+          unless line.success?
+            reject("sandbox_projection_incomplete", "sandbox line basis could not be selected")
+            return
+          end
+
+          Jumbotron::SandboxProjectionData::Game.new(
+            source_game_id: game.id,
+            event_id: "#{projection.name}:source-game:#{game.id}",
+            competition_id: "#{projection.name}:source-competition:#{game.id}",
+            scheduled_at: shift_time(game.scheduled_at, calendar),
+            season: projection.sandbox_season.name,
+            season_phase: game.season_phase.name,
+            week_number: game.schedule_group.number,
+            week_name: game.schedule_group.name,
+            neutral_site: game.neutral_site,
+            home: raw.fetch(:home),
+            away: raw.fetch(:away),
+            home_spread: line.data[:home_spread],
+            total: line.data[:total],
+            line_fingerprint: line.data[:line_fingerprint],
+            line_source: line.data[:line_source]
+          )
+        end
+
+        def shift_time(time, calendar)
+          time.in_time_zone(calendar.fetch(:zone))
+              .advance(days: calendar.fetch(:date_shift_days))
+              .utc
+        end
+
+        def reject_calendar(code, message)
+          reject(code, message)
+          nil
+        end
+
+        def reject(code, message)
+          context.fail!(
+            application_error: Jumbotron::Errors::Sandbox::ProjectionRejectedError.new(
+              details: { code: code, message: message }
+            )
+          )
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength

data/app/services/jumbotron/services/sandbox/project_game.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Sandbox
+      class ProjectGame < CommandTower::Services::ApplicationService
+        validate :projection, required: true
+        validate :projected_game, required: true
+        validate :observed_at, required: true
+        validate :change_set, required: true
+
+        def call # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          executed = Jumbotron::Services::Adapters::ExecuteEndpoint.call(
+            adapter: Jumbotron::Adapters::Sandbox::Nfl,
+            endpoint: :projection,
+            observed_at: observed_at,
+            acquisition: acquisition
+          )
+          return fail_from(executed) unless executed.success?
+
+          input = Array(executed.data[:sync_input]&.games).one? ? executed.data[:sync_input].games.first : nil
+          return reject("projection endpoint did not return one game") if input.nil?
+
+          graph = Jumbotron::Services::Canonical::UpsertGameGraph.call(
+            game_input: input,
+            league: projection.sandbox_season.league,
+            observed_at: observed_at,
+            change_set: change_set
+          )
+          return fail_from(graph) unless graph.success?
+
+          mapping = projection.sandbox_game_mappings.find_or_initialize_by(
+            source_game_id: projected_game.source_game_id
+          )
+          context.created = mapping.new_record?
+          mapping.assign_attributes(
+            sandbox_game: graph.data[:game],
+            home_spread: projected_game.home_spread,
+            total: projected_game.total,
+            line_fingerprint: projected_game.line_fingerprint
+          )
+          mapping.save!
+          context.mapping = mapping
+          context.game = graph.data[:game]
+        rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => e
+          reject(e.message)
+        end
+
+        private
+
+        def acquisition
+          projected_game.to_h.merge(
+            scheduled_at: projected_game.scheduled_at.iso8601,
+            home: projected_game.home.to_h,
+            away: projected_game.away.to_h
+          )
+        end
+
+        def fail_from(result)
+          context.fail!(application_error: Array(result.errors).first)
+        end
+
+        def reject(message)
+          context.fail!(
+            application_error: Jumbotron::Errors::Sandbox::ProjectionRejectedError.new(
+              details: { code: "sandbox_projection_incomplete", message: message }
+            )
+          )
+        end
+      end
+    end
+  end
+end