jumbotron 0.1.6 → 0.2.0

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/projection.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module Projection
+          module_function
+
+          def call(payload, observed_at:)
+            data = payload.symbolize_keys
+            Canonical::SyncInput.new(
+              observed_at: observed_at,
+              games: [game_input(data)],
+              teams: []
+            )
+          rescue ArgumentError, KeyError, TypeError => e
+            raise TransformError, "invalid sandbox projection: #{e.message}"
+          end
+
+          def game_input(data) # rubocop:disable Metrics/MethodLength
+            Canonical::GameInput.new(
+              provider_identities: game_identities(data),
+              scheduled_at: Time.iso8601(data.fetch(:scheduled_at).to_s),
+              lifecycle: "scheduled",
+              neutral_site: data.fetch(:neutral_site, false),
+              season_year: data.fetch(:season),
+              season_phase_key: data.fetch(:season_phase),
+              schedule_group: schedule_group(data),
+              venue: nil,
+              participants: %i[home away].map { |role| participant(data.fetch(role), role) },
+              progress: nil
+            )
+          end
+          private_class_method :game_input
+
+          def game_identities(data)
+            event_id = data.fetch(:event_id).to_s
+            competition_id = data.fetch(:competition_id, event_id).to_s
+            [
+              Canonical::ProviderIdentityRef.new(provider: "sandbox", namespace: "event", id: event_id),
+              Canonical::ProviderIdentityRef.new(
+                provider: "sandbox",
+                namespace: "competition",
+                id: competition_id
+              )
+            ].uniq
+          end
+          private_class_method :game_identities
+
+          def schedule_group(data)
+            number = Integer(data.fetch(:week_number))
+            Canonical::ScheduleGroupInput.new(
+              kind: "week",
+              number: number,
+              name: data.fetch(:week_name).to_s
+            )
+          end
+          private_class_method :schedule_group
+
+          def participant(raw, role) # rubocop:disable Metrics/MethodLength
+            data = raw.symbolize_keys
+            Canonical::ParticipantInput.new(
+              provider_identities: [
+                Canonical::ProviderIdentityRef.new(
+                  provider: "espn",
+                  namespace: "team",
+                  id: data.fetch(:provider_id).to_s
+                )
+              ],
+              team_name: data.fetch(:name).to_s,
+              team_nickname: data[:nickname].presence,
+              team_abbreviation: data[:abbreviation].presence,
+              role: role.to_s,
+              score: nil,
+              result: nil,
+              record_summary: nil
+            )
+          end
+          private_class_method :participant
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/scoreboard.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        class Scoreboard
+          def self.call(payload, observed_at:)
+            data = payload.symbolize_keys
+            resolved = resolve_observation(data.fetch(:game_id), observed_at)
+            Canonical::SyncInput.new(
+              observed_at: observed_at,
+              games: [game_input(data, resolved)],
+              teams: []
+            )
+          rescue ArgumentError, KeyError, TypeError => e
+            raise TransformError, "invalid sandbox scoreboard observation: #{e.message}"
+          end
+
+          def self.resolve_observation(game_id, observed_at)
+            resolved = Jumbotron::Services::Sandbox::ResolveGameObservation.call(
+              game_id: game_id,
+              observed_at: observed_at
+            )
+            return resolved.data if resolved.success?
+
+            error = Array(resolved.errors).first
+            raise TransformError, error.respond_to?(:message) ? error.message : "sandbox observation failed"
+          end
+          private_class_method :resolve_observation
+
+          def self.game_input(data, resolved)
+            event_id = data.fetch(:event_id).to_s
+            competition_id = data[:competition_id].presence || event_id
+            Canonical::GameInput.new(**game_attributes(data, event_id, competition_id, resolved))
+          end
+          private_class_method :game_input
+
+          def self.game_attributes(data, event_id, competition_id, resolved) # rubocop:disable Metrics/MethodLength
+            observation = resolved.fetch(:observation)
+            {
+              provider_identities: game_identities(event_id, competition_id),
+              scheduled_at: resolved.fetch(:scheduled_at),
+              lifecycle: observation.lifecycle,
+              neutral_site: false,
+              season_year: season_identity(data.fetch(:season_year)),
+              season_phase_key: data.fetch(:season_phase_key).to_s,
+              schedule_group: schedule_group(data.fetch(:week_number)),
+              venue: nil,
+              participants: %i[home away].map do |role|
+                participant(data.fetch(role), role, observation)
+              end,
+              progress: observation.progress
+            }
+          end
+          private_class_method :game_attributes
+
+          def self.season_identity(value)
+            Integer(value, exception: false) || value.to_s
+          end
+          private_class_method :season_identity
+
+          def self.game_identities(event_id, competition_id)
+            [
+              Canonical::ProviderIdentityRef.new(provider: "sandbox", namespace: "event", id: event_id),
+              Canonical::ProviderIdentityRef.new(
+                provider: "sandbox",
+                namespace: "competition",
+                id: competition_id.to_s
+              )
+            ].uniq
+          end
+          private_class_method :game_identities
+
+          def self.schedule_group(number)
+            week = Integer(number)
+            Canonical::ScheduleGroupInput.new(kind: "week", number: week, name: "Week #{week}")
+          end
+          private_class_method :schedule_group
+
+          def self.participant(raw, role, observation)
+            data = raw.symbolize_keys
+            Canonical::ParticipantInput.new(**participant_attributes(data, role, observation))
+          end
+          private_class_method :participant
+
+          def self.participant_attributes(data, role, observation)
+            {
+              provider_identities: [team_identity(data.fetch(:provider_id))],
+              team_name: data.fetch(:name).to_s,
+              team_nickname: data[:nickname].presence,
+              team_abbreviation: data[:abbreviation].presence,
+              role: role.to_s,
+              score: observation.public_send("#{role}_score"),
+              result: observation.public_send("#{role}_result"),
+              record_summary: nil
+            }
+          end
+          private_class_method :participant_attributes
+
+          def self.team_identity(provider_id)
+            Canonical::ProviderIdentityRef.new(
+              provider: "espn",
+              namespace: "team",
+              id: provider_id.to_s
+            )
+          end
+          private_class_method :team_identity
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/synthetic_observation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module SyntheticObservation
+          Current = Data.define(:lifecycle, :progress, :home_score, :away_score)
+          Observation = Data.define(
+            :lifecycle,
+            :progress,
+            :home_score,
+            :away_score,
+            :home_result,
+            :away_result
+          )
+
+          QUARTER_SECONDS = TimelineObservation::QUARTER_SECONDS
+          HALFTIME_SECONDS = TimelineObservation::HALFTIME_SECONDS
+          TOTAL_SECONDS = TimelineObservation::TOTAL_SECONDS
+
+          module_function
+
+          def call(now:, kickoff:, plan:, current:)
+            proposed = TimelineObservation.call(now: now, kickoff: kickoff, plan: plan)
+            MonotonicObservation.call(proposed: proposed, current: current, plan: plan)
+          end
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/timeline_observation.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module TimelineObservation
+          QUARTER_SECONDS = 27.5.minutes.to_i
+          HALFTIME_SECONDS = 10.minutes.to_i
+          ACTIVE_SECONDS = QUARTER_SECONDS * 4
+          TOTAL_SECONDS = ACTIVE_SECONDS + HALFTIME_SECONDS
+          GAME_CLOCK_SECONDS = 15.minutes.to_i
+          STAGES = [
+            [QUARTER_SECONDS, :q1],
+            [QUARTER_SECONDS * 2, :q2],
+            [(QUARTER_SECONDS * 2) + HALFTIME_SECONDS, :halftime],
+            [(QUARTER_SECONDS * 3) + HALFTIME_SECONDS, :q3],
+            [TOTAL_SECONDS, :q4]
+          ].freeze
+
+          module_function
+
+          def call(now:, kickoff:, plan:)
+            elapsed = elapsed_seconds(now, kickoff)
+            return scheduled_observation if elapsed.negative?
+            return completed_observation(plan) if elapsed >= TOTAL_SECONDS
+
+            stage_observation(stage_for(elapsed), elapsed, plan)
+          end
+
+          def elapsed_seconds(now, kickoff)
+            now.to_time.to_f - kickoff.to_time.to_f
+          rescue ArgumentError, NoMethodError, TypeError
+            raise ArgumentError, "sandbox observation requires valid now and kickoff times"
+          end
+          private_class_method :elapsed_seconds
+
+          def stage_for(elapsed)
+            STAGES.find { |ending, _stage| elapsed < ending }.last
+          end
+          private_class_method :stage_for
+
+          def stage_observation(stage, elapsed, plan)
+            return halftime_observation(plan) if stage == :halftime
+
+            quarter = { q1: 1, q2: 2, q3: 3, q4: 4 }.fetch(stage)
+            local = local_elapsed(stage, elapsed)
+            active_observation(quarter, local, active_elapsed(stage, local), plan)
+          end
+          private_class_method :stage_observation
+
+          def local_elapsed(stage, elapsed)
+            offsets = {
+              q1: 0,
+              q2: QUARTER_SECONDS,
+              q3: (QUARTER_SECONDS * 2) + HALFTIME_SECONDS,
+              q4: (QUARTER_SECONDS * 3) + HALFTIME_SECONDS
+            }
+            elapsed - offsets.fetch(stage)
+          end
+          private_class_method :local_elapsed
+
+          def active_elapsed(stage, local)
+            completed_quarters = { q1: 0, q2: 1, q3: 2, q4: 3 }.fetch(stage)
+            (completed_quarters * QUARTER_SECONDS) + local
+          end
+          private_class_method :active_elapsed
+
+          def scheduled_observation
+            ObservationValues.observation(lifecycle: "scheduled")
+          end
+          private_class_method :scheduled_observation
+
+          def active_observation(quarter, local, active_elapsed, plan)
+            fraction = active_elapsed / ACTIVE_SECONDS.to_f
+            ObservationValues.observation(
+              lifecycle: "in_progress",
+              progress: ObservationValues.progress(state: "active", quarter: quarter, clock: clock(local)),
+              home_score: ObservationValues.score_at(plan.home_score, fraction),
+              away_score: ObservationValues.score_at(plan.away_score, fraction)
+            )
+          end
+          private_class_method :active_observation
+
+          def halftime_observation(plan)
+            ObservationValues.observation(
+              lifecycle: "in_progress",
+              progress: ObservationValues.progress(state: "intermission", quarter: 2),
+              home_score: ObservationValues.score_at(plan.home_score, 0.5),
+              away_score: ObservationValues.score_at(plan.away_score, 0.5)
+            )
+          end
+          private_class_method :halftime_observation
+
+          def completed_observation(plan)
+            home_result, away_result = ObservationValues.results(plan.home_score, plan.away_score)
+            ObservationValues.observation(
+              lifecycle: "completed",
+              home_score: plan.home_score,
+              away_score: plan.away_score,
+              home_result: home_result,
+              away_result: away_result
+            )
+          end
+          private_class_method :completed_observation
+
+          def clock(local_seconds)
+            ObservationValues.clock(
+              local_seconds: local_seconds,
+              quarter_seconds: QUARTER_SECONDS,
+              game_clock_seconds: GAME_CLOCK_SECONDS
+            )
+          end
+          private_class_method :clock
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competitor.rb

@@ -13,6 +13,7 @@ module Jumbotron
             field :winner, type: Support.types.boolean, nullable: true
             field :order, type: Support.types.integer, nullable: true
             field :team, type: Team::Result, required: true
+            field :records, type: Support.types.array(CompetitorRecord::Result), nullable: true
           end
 
           def self.call(payload)
@@ -25,10 +26,22 @@ module Jumbotron
               score: coerce_score(Support.payload.fetch(payload, "score")),
               winner: Support.payload.fetch(payload, "winner"),
               order: Support.payload.fetch(payload, "order"),
-              team: Support.nest("team", Support.payload.fetch(payload, "team")) { |raw| Team.call(raw) }
+              team: Support.nest("team", Support.payload.fetch(payload, "team")) { |raw| Team.call(raw) },
+              records: map_records(Support.payload.fetch(payload, "records"))
             )
           end
 
+          def self.map_records(raw)
+            return nil if raw.equal?(Support.missing) || raw.nil?
+
+            Array(raw).each_with_index.map do |item, index|
+              CompetitorRecord.call(item)
+            rescue CommandTower::Clients::Errors::DeserializationError => e
+              raise CommandTower::Deserializers::Clients::Errors.prefix(e, "records[#{index}]")
+            end
+          end
+          private_class_method :map_records
+
           def self.coerce_id(raw)
             return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
 

data/app/deserializers/jumbotron/deserializers/clients/espn/competitor_record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class CompetitorRecord
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :type, type: Support.types.string, required: true
+            field :summary, type: Support.types.string, required: true
+            field :name, type: Support.types.string, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "competitor.record")
+
+            Result.build!(
+              type: Support.payload.fetch(payload, "type"),
+              summary: Support.payload.fetch(payload, "summary"),
+              name: Support.payload.fetch(payload, "name")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/venue.rb

@@ -9,6 +9,7 @@ module Jumbotron
             field :id, type: Support.types.string, required: true
             field :full_name, type: Support.types.string, required: true
             field :indoor, type: Support.types.boolean, nullable: true
+            field :address, type: VenueAddress::Result, nullable: true
           end
 
           def self.call(payload)
@@ -17,10 +18,18 @@ module Jumbotron
             Result.build!(
               id: coerce_id(Support.payload.fetch(payload, "id")),
               full_name: Support.payload.fetch(payload, "fullName"),
-              indoor: Support.payload.fetch(payload, "indoor")
+              indoor: Support.payload.fetch(payload, "indoor"),
+              address: map_address(Support.payload.fetch(payload, "address"))
             )
           end
 
+          def self.map_address(raw)
+            return nil if raw.equal?(Support.missing) || raw.nil?
+
+            VenueAddress.call(raw)
+          end
+          private_class_method :map_address
+
           def self.coerce_id(raw)
             return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
 

data/app/deserializers/jumbotron/deserializers/clients/espn/venue_address.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class VenueAddress
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :city, type: Support.types.string, nullable: true
+            field :state, type: Support.types.string, nullable: true
+            field :country, type: Support.types.string, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "venue.address")
+
+            Result.build!(
+              city: Support.payload.fetch(payload, "city"),
+              state: Support.payload.fetch(payload, "state"),
+              country: Support.payload.fetch(payload, "country")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/public/register_sandbox_projection.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Public
+      class RegisterSandboxProjection < CommandTower::Deserializers::ApplicationDeserializer
+        FIELDS = %i[sport league season season_phase].freeze
+
+        def call(params)
+          name = unwrap(require_string(unwrap(fetch_param(params, :name)), field: "name"))
+          return name if deserializer_result?(name)
+
+          source = unwrap(fetch_param(params, :source))
+          return source if deserializer_result?(source)
+          return invalid("source must be a hash") unless source.is_a?(Hash)
+
+          selector = parse_selector(source)
+          return selector if deserializer_result?(selector)
+
+          success(Jumbotron::Public::RegisterSandboxProjectionRequest.new(name: name, source: selector))
+        end
+
+        private
+
+        def parse_selector(source)
+          values = FIELDS.to_h do |field|
+            value = source[field] || source[field.to_s]
+            parsed = unwrap(require_string(value, field: "source.#{field}"))
+            return parsed if deserializer_result?(parsed)
+
+            [field, parsed]
+          end
+          Jumbotron::Public::SandboxScheduleSelector.new(**values)
+        end
+
+        def invalid(message)
+          failure(errors: [{ code: "invalid_request", message: message }])
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/public/reset_sandbox_projection.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Jumbotron
+  module Deserializers
+    module Public
+      class ResetSandboxProjection < CommandTower::Deserializers::ApplicationDeserializer
+        def call(params)
+          sandbox = unwrap(require_string(unwrap(fetch_param(params, :sandbox)), field: "sandbox"))
+          return sandbox if deserializer_result?(sandbox)
+
+          start_week = positive_integer(params, :start_week)
+          return start_week if deserializer_result?(start_week)
+
+          anchor_day = positive_integer(params, :anchor_day)
+          return anchor_day if deserializer_result?(anchor_day)
+
+          now = parse_time(unwrap(fetch_param(params, :now)))
+          return now if deserializer_result?(now)
+
+          success(
+            Jumbotron::Public::ResetSandboxProjectionRequest.new(
+              sandbox: sandbox,
+              start_week: start_week,
+              anchor_day: anchor_day,
+              now: now
+            )
+          )
+        end
+
+        private
+
+        def positive_integer(params, field)
+          raw = unwrap(fetch_param(params, field))
+          return raw if deserializer_result?(raw)
+
+          unwrap(require_integer(raw, field: field.to_s, min: 1))
+        end
+
+        def parse_time(raw)
+          return raw if raw.is_a?(Time) || raw.is_a?(ActiveSupport::TimeWithZone)
+
+          Time.iso8601(raw.to_s)
+        rescue ArgumentError, TypeError
+          failure(errors: [{ code: "invalid_request", message: "now must be an ISO8601 time" }])
+        end
+      end
+    end
+  end
+end

data/app/errors/jumbotron/error.rb

@@ -2,5 +2,12 @@
 
 module Jumbotron
   class Error < StandardError
+    attr_reader :code, :details
+
+    def initialize(message = nil, code: "internal_error", details: {})
+      @code = code.to_s
+      @details = details || {}
+      super(message)
+    end
   end
 end

data/app/errors/jumbotron/errors/sandbox.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Errors
+    module Sandbox
+      class InvalidGameError < CommandTower::Errors::ApplicationError
+        def code
+          "invalid_sandbox_game"
+        end
+
+        def message
+          "game is not an eligible sandbox game"
+        end
+      end
+
+      class OutcomeLineUnavailableError < CommandTower::Errors::ApplicationError
+        def code
+          "sandbox_outcome_line_unavailable"
+        end
+
+        def message
+          "sandbox outcome requires current home spread and over total lines"
+        end
+      end
+
+      class InvalidProgressionStateError < CommandTower::Errors::ApplicationError
+        def code
+          "invalid_sandbox_progression_state"
+        end
+
+        def message
+          details.is_a?(Hash) && details[:message].present? ? details[:message].to_s : "sandbox state cannot progress"
+        end
+      end
+
+      class ProjectionNotFoundError < CommandTower::Errors::ApplicationError
+        def code
+          "sandbox_not_found"
+        end
+
+        def message
+          "sandbox projection was not found"
+        end
+      end
+
+      class ProjectionConflictError < CommandTower::Errors::ApplicationError
+        def code
+          "sandbox_projection_conflict"
+        end
+
+        def message
+          "sandbox projection conflicts with its registered source"
+        end
+      end
+
+      class ProjectionRejectedError < CommandTower::Errors::ApplicationError
+        def code
+          details.is_a?(Hash) && details[:code].present? ? details[:code].to_s : "sandbox_projection_incomplete"
+        end
+
+        def message
+          details.is_a?(Hash) && details[:message].present? ? details[:message].to_s : "sandbox projection was rejected"
+        end
+      end
+    end
+  end
+end

data/app/errors/jumbotron/sandbox_reset_rejected_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class SandboxResetRejectedError < Error
+  end
+end