jumbotron 0.1.7 → 0.2.0

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Sandbox
+      class RegisterProjection < CommandTower::Services::ApplicationService
+        validate :request, required: true
+
+        def call # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          source_season, source_phase = resolve_source
+          return if source_season.nil?
+
+          existing = Jumbotron::SandboxProjection.find_by(name: request.name)
+          return reuse_or_reject(existing, source_season, source_phase) if existing
+
+          sandbox_league = ensure_sandbox_league
+          return if sandbox_league.nil?
+
+          sandbox_season = Jumbotron::Season.find_or_create_by!(league: sandbox_league, name: request.name)
+          context.projection = Jumbotron::SandboxProjection.create!(
+            name: request.name,
+            source_season: source_season,
+            source_anchor_phase: source_phase,
+            sandbox_season: sandbox_season,
+            adapter_id: "sandbox_nfl",
+            calendar_time_zone: "America/New_York"
+          )
+        rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => e
+          reject("sandbox_projection_conflict", e.message)
+        end
+
+        private
+
+        def resolve_source # rubocop:disable Metrics/AbcSize
+          selector = request.source
+          sport = Jumbotron::Sport.where("LOWER(name) = ?", selector.sport.downcase).first
+          league = sport.leagues.where("LOWER(name) = ?", selector.league.downcase).first if sport
+          season = league.seasons.where("LOWER(name) = ?", selector.season.downcase).first if league
+          phase = season.season_phases.where("LOWER(name) = ?", selector.season_phase.downcase).first if season
+          return [season, phase] if season && phase
+
+          reject("source_season_not_found", "registered source season or phase was not found")
+          [nil, nil]
+        end
+
+        def ensure_sandbox_league
+          result = Jumbotron::Services::Adapters::EnsureLeague.call(
+            adapter: Jumbotron::Adapters::Sandbox::Nfl
+          )
+          return result.data[:league] if result.success?
+
+          reject("sandbox_projection_conflict", result.errors.first.to_s)
+          nil
+        end
+
+        def reuse_or_reject(existing, source_season, source_phase)
+          if existing.source_season_id == source_season.id &&
+             existing.source_anchor_phase_id == source_phase.id
+            context.projection = existing
+            return
+          end
+
+          reject("sandbox_projection_conflict", "sandbox name is already registered to another source")
+        end
+
+        def reject(code, message)
+          context.fail!(
+            application_error: Jumbotron::Errors::Sandbox::ProjectionRejectedError.new(
+              details: { code: code, message: message }
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Sandbox
+      class RemoveEmptyProjectionGeometry < CommandTower::Services::ApplicationService
+        validate :projection, required: true
+
+        def call
+          remove_empty_groups
+          remove_empty_phases
+        rescue ActiveRecord::ActiveRecordError => e
+          reject(e)
+        end
+
+        private
+
+        def reject(error)
+          context.fail!(
+            application_error: Jumbotron::Errors::Sandbox::ProjectionRejectedError.new(
+              details: {
+                code: "sandbox_projection_incomplete",
+                message: "stale sandbox schedule geometry could not be removed",
+                failure: error.class.name
+              }
+            )
+          )
+        end
+
+        def remove_empty_groups
+          projection.sandbox_season.schedule_groups
+                    .left_outer_joins(:games)
+                    .where(jumbotron_games: { id: nil })
+                    .destroy_all
+        end
+
+        def remove_empty_phases
+          projection.sandbox_season.season_phases
+                    .left_outer_joins(:games, :schedule_groups)
+                    .where(jumbotron_games: { id: nil }, jumbotron_schedule_groups: { id: nil })
+                    .destroy_all
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Sandbox
+      class RemoveMappedGame < CommandTower::Services::ApplicationService
+        validate :mapping, required: true
+
+        def call # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          game = mapping.sandbox_game
+          mapping.destroy!
+          game.reload
+          Jumbotron::SandboxGamePlan.find_by(game_id: game.id)&.destroy!
+          game.line_observations.destroy_all
+          game.game_participants.destroy_all
+          game.provider_identities.destroy_all
+          game.destroy!
+          context.removed_game_id = game.id
+        rescue ActiveRecord::ActiveRecordError => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Sandbox::ProjectionRejectedError.new(
+              details: { code: "sandbox_projection_incomplete", message: e.message }
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Jumbotron
+  module Services
+    module Sandbox
+      class ResolveGameObservation < CommandTower::Services::ApplicationService
+        validate :game_id, required: true
+        validate :observed_at, required: true
+
+        def call
+          game = resolve_game
+          return if game.nil?
+
+          plan = resolve_plan(game)
+          return if plan.nil?
+
+          assign_observation(game, plan)
+        rescue ArgumentError, TypeError => e
+          fail_invalid_progression(e)
+        end
+
+        private
+
+        def resolve_game
+          game = Game.find_by(id: game_id)
+          return game if sandbox_game?(game)
+
+          context.fail!(application_error: Errors::Sandbox::InvalidGameError.new)
+          nil
+        end
+
+        def assign_observation(game, plan)
+          game.reload
+          context.plan = plan
+          context.scheduled_at = game.scheduled_at
+          context.observation = observation_for(game, plan)
+        end
+
+        def fail_invalid_progression(error)
+          context.fail!(
+            application_error: Errors::Sandbox::InvalidProgressionStateError.new(
+              details: { message: error.message }
+            )
+          )
+        end
+
+        def sandbox_game?(game)
+          return false if game.nil? || game.league.name != "nfl-sandbox"
+
+          game.provider_identities.any? do |identity|
+            identity.provider == "sandbox" && identity.object_namespace == "event"
+          end
+        end
+
+        def resolve_plan(game)
+          game.with_lock do
+            game.reload
+            game.sandbox_game_plan || create_plan(game)
+          end
+        end
+
+        def create_plan(game)
+          lines = Canonical::DeriveConsensusLine.call(game: game)
+          return fail_missing_lines unless lines.success?
+
+          candidates = outcome_candidates(Array(lines.data[:consensus_lines]))
+          return fail_missing_lines if candidates.empty?
+
+          selected = candidates.fetch(SecureRandom.random_number(candidates.length))
+          game.create_sandbox_game_plan!(
+            home_score: selected.home_score,
+            away_score: selected.away_score,
+            selected_at: observed_at
+          )
+        end
+
+        def outcome_candidates(lines)
+          spread = lines.find { |line| line.market == "spread" && line.outcome == "home" }
+          total = lines.find { |line| line.market == "total" && line.outcome == "over" }
+          return [] if spread.nil? || total.nil?
+
+          Jumbotron::Adapters::Sandbox::NflHelpers::OutcomeCandidates.call(
+            home_spread: spread.line_value,
+            total: total.line_value
+          )
+        end
+
+        def fail_missing_lines
+          context.fail!(application_error: Errors::Sandbox::OutcomeLineUnavailableError.new)
+          nil
+        end
+
+        def observation_for(game, plan)
+          Jumbotron::Adapters::Sandbox::NflHelpers::SyntheticObservation.call(
+            now: observed_at,
+            kickoff: game.scheduled_at,
+            plan: plan,
+            current: Jumbotron::Adapters::Sandbox::NflHelpers::CurrentObservationState.call(game)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Sandbox
+      class SeedProjectedGame < CommandTower::Services::ApplicationService
+        validate :game, required: true
+        validate :observed_at, required: true
+        validate :change_set, required: true
+
+        def call
+          clear_previous_generation
+          return unless persist_lines
+          return unless usable_consensus?
+          return unless apply_scoreboard
+
+          context.game = game.reload
+        end
+
+        private
+
+        def clear_previous_generation
+          game.sandbox_game_plan&.destroy!
+          game.line_observations.destroy_all
+        end
+
+        def persist_lines
+          scope = Jumbotron::Adapters::Sandbox::Nfl.line_acquisition_scope_for(game.reload)
+          return reject("sandbox line scope is unavailable") if scope.nil?
+
+          result = Jumbotron::Services::Adapters::ExecuteLineAcquisitionScope.call(
+            adapter: Jumbotron::Adapters::Sandbox::Nfl,
+            acquisition: scope.fetch(:acquisition),
+            observed_at: observed_at
+          )
+          return true if result.success? && result.data[:outcome] == :succeeded
+
+          reject("sandbox line persistence failed")
+          false
+        end
+
+        def usable_consensus? # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          result = Jumbotron::Services::Canonical::DeriveConsensusLine.call(game: game.reload)
+          return reject("sandbox consensus could not be derived") 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" }
+          return true if spread && total && spread.line_value == game.sandbox_game_mapping.home_spread &&
+                         total.line_value == game.sandbox_game_mapping.total
+
+          reject("sandbox consensus does not match selected line basis")
+          false
+        end
+
+        def apply_scoreboard # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          scope = Jumbotron::Adapters::Sandbox::Nfl.acquisition_scope_for(game.reload)
+          return reject("sandbox scoreboard scope is unavailable") if scope.nil?
+
+          executed = Jumbotron::Services::Adapters::ExecuteEndpoint.call(
+            adapter: Jumbotron::Adapters::Sandbox::Nfl,
+            endpoint: :scoreboard,
+            observed_at: observed_at,
+            acquisition: scope.fetch(:acquisition)
+          )
+          return fail_from(executed) unless executed.success?
+
+          input = executed.data[:sync_input].games.first
+          result = Jumbotron::Services::Canonical::UpsertGameGraph.call(
+            game_input: input,
+            league: game.league,
+            observed_at: observed_at,
+            change_set: change_set
+          )
+          return true if result.success?
+
+          fail_from(result)
+        end
+
+        def fail_from(result)
+          context.fail!(application_error: Array(result.errors).first)
+          nil
+        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

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "digest"
+
+module Jumbotron
+  module Services
+    module Sandbox
+      class SelectLineBasis < CommandTower::Services::ApplicationService
+        SPREADS = (-21..21).reject(&:zero?).map { |value| BigDecimal(value.to_s) / 2 }.freeze
+        TOTALS = (75..109).map { |value| BigDecimal(value.to_s) / 2 }.freeze
+
+        validate :source_game_id, required: true
+        validate :reset_fingerprint, required: true
+        validate :source_spread, required: false
+        validate :source_total, required: false
+
+        def call # rubocop:disable Metrics/AbcSize
+          source_pair = normalized_source_pair
+          pair = source_pair || fallback_pair
+          context.home_spread = pair.fetch(:home_spread)
+          context.total = pair.fetch(:total)
+          context.line_source = source_pair ? "source_consensus" : "synthetic_fallback"
+          context.line_fingerprint = Digest::SHA256.hexdigest(
+            "#{reset_fingerprint}:#{source_game_id}:#{context.home_spread}:#{context.total}"
+          )
+        end
+
+        private
+
+        def normalized_source_pair
+          return if source_spread.nil? || source_total.nil?
+
+          spread = round_half(source_spread)
+          total = round_half(source_total)
+          return unless total.positive? && implied_scores(spread, total).all?(&:positive?)
+
+          { home_spread: spread, total: total }
+        rescue ArgumentError, TypeError
+          nil
+        end
+
+        def fallback_pair
+          candidates = weighted_fallback_candidates
+          index = Digest::SHA256.hexdigest("#{reset_fingerprint}:#{source_game_id}").to_i(16) % candidates.length
+          candidates.fetch(index)
+        end
+
+        def weighted_fallback_candidates
+          SPREADS.product(TOTALS).filter_map do |spread, total|
+            next unless implied_scores(spread, total).all? { |score| score.between?(10, 38) }
+
+            pair = { home_spread: spread, total: total }
+            weight = (spread.abs <= 6.5 ? 2 : 1) * (total.between?(41.5, 48.5) ? 2 : 1)
+            Array.new(weight, pair)
+          end.flatten
+        end
+
+        def implied_scores(spread, total)
+          [(total - spread) / 2, (total + spread) / 2]
+        end
+
+        def round_half(value)
+          BigDecimal((BigDecimal(value.to_s) * 2).round.to_s) / 2
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Sandbox
+      class ValidateProjectedSeason < CommandTower::Services::ApplicationService
+        validate :projection, required: true
+        validate :snapshot, required: true
+        validate :now, required: true
+
+        def call # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+          mappings = projection.sandbox_game_mappings.includes(
+            sandbox_game: %i[sandbox_game_plan provider_identities line_observations schedule_group]
+          ).to_a
+          return reject("mapping coverage is incomplete") unless mapping_coverage?(mappings)
+          return reject("sandbox game identity is invalid") unless mappings.all? { |mapping| valid_identity?(mapping) }
+
+          complete = mappings.all? { |mapping| complete_state?(mapping) }
+          return reject("sandbox lines or outcomes are incomplete") unless complete
+          return reject("sandbox week windows overlap") unless non_overlapping?(mappings)
+
+          start_games = mappings.filter_map do |mapping|
+            game = mapping.sandbox_game
+            game if game.schedule_group.number == snapshot.start_week
+          end
+          context.start_week_game_count = start_games.count
+          context.naturally_locked_game_count = start_games.count { |game| game.scheduled_at <= now }
+        end
+
+        private
+
+        def mapping_coverage?(mappings)
+          mappings.map(&:source_game_id).sort == snapshot.games.map(&:source_game_id).sort &&
+            mappings.map(&:sandbox_game_id).uniq.length == mappings.length
+        end
+
+        def valid_identity?(mapping)
+          game = mapping.sandbox_game
+          game.season_id == projection.sandbox_season_id &&
+            game.league.name == "nfl-sandbox" &&
+            game.provider_identities.any? do |identity|
+              identity.provider == "sandbox" && identity.object_namespace == "event"
+            end
+        end
+
+        def complete_state?(mapping) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          game = mapping.sandbox_game
+          return false if game.sandbox_game_plan.nil?
+
+          result = Jumbotron::Services::Canonical::DeriveConsensusLine.call(game: game)
+          return false 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 == mapping.home_spread && total&.line_value == mapping.total
+        end
+
+        def non_overlapping?(mappings)
+          windows = mappings.group_by { |mapping| mapping.sandbox_game.schedule_group_id }.values.map do |members|
+            times = members.map { |mapping| mapping.sandbox_game.scheduled_at }
+            times.minmax
+          end.sort_by(&:first)
+          windows.each_cons(2).all? { |left, right| left.last < right.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

data/app/workflows/jumbotron/workflows/public_read.rb

@@ -21,8 +21,9 @@ module Jumbotron
         error = Array(result.errors).first
         code = error.respond_to?(:code) ? error.code.to_s : "invalid_request"
         message = error.respond_to?(:message) ? error.message : error.to_s
+        details = error.respond_to?(:details) && error.details.is_a?(Hash) ? error.details.except(:message) : {}
         status = Public::TranslateOutcome::NOT_FOUND_CODES.include?(code) ? :not_found : :unprocessable_entity
-        failure(errors: [{ code: code, message: message }], http_status: status)
+        failure(errors: [{ code: code, message: message, details: details }], http_status: status)
       end
     end
   end

data/app/workflows/jumbotron/workflows/sandbox/register_projection_workflow.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    module Sandbox
+      class RegisterProjectionWorkflow < CommandTower::Workflows::ApplicationWorkflow
+        include Jumbotron::Workflows::PublicRead
+
+        retry_strategy :none
+
+        def call(**kwargs)
+          deserialized = Jumbotron::Deserializers::Public::RegisterSandboxProjection.call(kwargs)
+          return map_deserializer_failure(deserialized) unless deserialized.success?
+
+          transaction do
+            registered = Jumbotron::Services::Sandbox::RegisterProjection.call(request: deserialized.input)
+            fail_transaction!(map_service_failure(registered)) unless registered.success?
+
+            assembled = Jumbotron::Services::Public::AssembleSandboxProjection.call(
+              projection: registered.data[:projection]
+            )
+            fail_transaction!(map_service_failure(assembled)) unless assembled.success?
+
+            success(
+              payload: { sandbox_projection: assembled.data[:public_projection] },
+              http_status: :ok
+            )
+          end
+        end
+      end
+    end
+  end
+end