jumbotron 0.1.6 → 0.2.0

data/app/models/jumbotron/canonical.rb

@@ -4,13 +4,17 @@ module Jumbotron
   module Canonical
     ProviderIdentityRef = Data.define(:provider, :namespace, :id)
 
-    TeamInput = Data.define(:provider_identities, :name, :nickname) do
-      def initialize(provider_identities:, name:, nickname: nil)
+    TeamInput = Data.define(:provider_identities, :name, :nickname, :abbreviation) do
+      def initialize(provider_identities:, name:, nickname: nil, abbreviation: nil)
         super
       end
     end
 
-    VenueInput = Data.define(:provider_identities, :name)
+    VenueInput = Data.define(:provider_identities, :name, :city, :region) do
+      def initialize(provider_identities:, name:, city: nil, region: nil)
+        super
+      end
+    end
 
     ParticipantInput = Data.define(
       :provider_identities,
@@ -18,9 +22,20 @@ module Jumbotron
       :role,
       :score,
       :result,
-      :team_nickname
+      :team_nickname,
+      :team_abbreviation,
+      :record_summary
     ) do
-      def initialize(provider_identities:, team_name:, role:, score:, result:, team_nickname: nil)
+      def initialize(
+        provider_identities:,
+        team_name:,
+        role:,
+        score:,
+        result:,
+        team_nickname: nil,
+        team_abbreviation: nil,
+        record_summary: nil
+      )
         super
       end
     end

data/app/models/jumbotron/game.rb

@@ -34,6 +34,17 @@ module Jumbotron
     has_many :teams, through: :game_participants
     has_many :provider_identities, as: :target, inverse_of: :target, dependent: :restrict_with_exception
     has_many :line_observations, inverse_of: :game, dependent: :restrict_with_exception
+    has_one :sandbox_game_plan, inverse_of: :game, dependent: :restrict_with_exception
+    has_many :source_sandbox_game_mappings,
+             class_name: "Jumbotron::SandboxGameMapping",
+             foreign_key: :source_game_id,
+             inverse_of: :source_game,
+             dependent: :restrict_with_exception
+    has_one :sandbox_game_mapping,
+            class_name: "Jumbotron::SandboxGameMapping",
+            foreign_key: :sandbox_game_id,
+            inverse_of: :sandbox_game,
+            dependent: :restrict_with_exception
 
     attribute :lifecycle, :string, default: "scheduled"
     attribute :neutral_site, :boolean, default: false

data/app/models/jumbotron/public/translate_outcome.rb

@@ -10,6 +10,7 @@ module Jumbotron
         season_not_found
         season_phase_not_found
         schedule_group_not_found
+        sandbox_not_found
       ].freeze
 
       module_function
@@ -25,29 +26,34 @@ module Jumbotron
       end
 
       def public_error_for(result)
-        code, message = error_code_and_message(result)
+        code, message, details = error_code_message_and_details(result)
         klass = exception_class_for(code)
-        klass.new(message)
+        klass.new(message, code: code, details: details)
       end
       module_function :public_error_for
 
-      def error_code_and_message(result)
+      def error_code_message_and_details(result) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         error = Array(result.errors).first
         case error
         when CommandTower::Errors::ApplicationError
-          [error.code.to_s, error.message]
+          [error.code.to_s, error.message, error.details || {}]
         when Hash
-          [(error[:code] || error["code"]).to_s, (error[:message] || error["message"]).to_s]
+          [
+            (error[:code] || error["code"]).to_s,
+            (error[:message] || error["message"]).to_s,
+            error[:details] || error["details"] || {}
+          ]
         else
-          ["internal_error", error.to_s]
+          ["internal_error", error.to_s, {}]
         end
       end
-      module_function :error_code_and_message
+      module_function :error_code_message_and_details
 
       def exception_class_for(code)
         return Jumbotron::NotFoundError if NOT_FOUND_CODES.include?(code)
         return Jumbotron::InvalidRequestError if code == "invalid_request"
         return Jumbotron::UnsupportedCapabilityError if code == "unsupported"
+        return Jumbotron::SandboxResetRejectedError if code.start_with?("sandbox_", "source_", "anchor_")
 
         Jumbotron::Error
       end

data/app/models/jumbotron/public.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jumbotron
-  module Public
+  module Public # rubocop:disable Metrics/ModuleLength
     ALLOWED_INCLUDES = %i[consensus current_lines consensus_constituents].freeze
 
     Sport = Data.define(:id, :name)
@@ -10,6 +10,23 @@ module Jumbotron
     SeasonPhase = Data.define(:id, :name)
     ScheduleGroup = Data.define(:id, :kind, :number, :name)
     ScheduleGroupEnumeration = Data.define(:groups, :completeness)
+    SandboxScheduleSelector = Data.define(:sport, :league, :season, :season_phase)
+    RegisterSandboxProjectionRequest = Data.define(:name, :source)
+    ResetSandboxProjectionRequest = Data.define(:sandbox, :start_week, :anchor_day, :now)
+    SandboxProjection = Data.define(:name, :source, :sandbox)
+    SandboxProjectionReset = Data.define(
+      :projection,
+      :source_anchor_date,
+      :target_anchor_date,
+      :date_shift_days,
+      :projected_game_count,
+      :added_game_count,
+      :updated_game_count,
+      :removed_game_count,
+      :start_week_game_count,
+      :naturally_locked_game_count,
+      :reset_at
+    )
     ScheduleGroupsRequest = Data.define(
       :league_id,
       :sport,
@@ -19,13 +36,21 @@ module Jumbotron
       :season_phase,
       :kind
     )
-    Team = Data.define(:id, :name, :nickname, :key) do
-      def initialize(id:, name:, key:, nickname: nil)
-        super(id:, name:, nickname:, key:)
+    Team = Data.define(:id, :name, :nickname, :key, :abbreviation) do
+      def initialize(id:, name:, key:, nickname: nil, abbreviation: nil)
+        super(id:, name:, nickname:, key:, abbreviation:)
+      end
+    end
+    Venue = Data.define(:id, :name, :city, :region) do
+      def initialize(id:, name:, city: nil, region: nil)
+        super
+      end
+    end
+    Participant = Data.define(:role, :score, :result, :team, :record) do
+      def initialize(role:, score:, result:, team:, record: nil)
+        super
       end
     end
-    Venue = Data.define(:id, :name)
-    Participant = Data.define(:role, :score, :result, :team)
     GameSegment = Data.define(:kind, :number)
     # Clock label text. Name is canonical/public contract, not Kernel#display.
     GameClock = Data.define(:mode, :seconds, :display) # rubocop:disable Lint/DataDefineOverride

data/app/models/jumbotron/sandbox_game_mapping.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class SandboxGameMapping < ApplicationRecord
+    belongs_to :sandbox_projection, inverse_of: :sandbox_game_mappings
+    belongs_to :source_game, class_name: "Jumbotron::Game", inverse_of: :source_sandbox_game_mappings
+    belongs_to :sandbox_game, class_name: "Jumbotron::Game", inverse_of: :sandbox_game_mapping
+
+    validates :source_game_id, uniqueness: { scope: :sandbox_projection_id }
+    validates :sandbox_game_id, uniqueness: true
+    validates :home_spread, :total, numericality: true
+    validates :line_fingerprint, presence: true
+    validate :games_are_in_expected_worlds
+
+    private
+
+    def games_are_in_expected_worlds
+      return if source_game.nil? || sandbox_game.nil?
+      return if source_game.league.name != "nfl-sandbox" && sandbox_game.league.name == "nfl-sandbox"
+
+      errors.add(:base, "mapping requires live source and sandbox target games")
+    end
+  end
+end

data/app/models/jumbotron/sandbox_game_plan.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class SandboxGamePlan < ApplicationRecord
+    IMMUTABLE_ATTRIBUTES = %w[game_id home_score away_score selected_at].freeze
+
+    belongs_to :game, inverse_of: :sandbox_game_plan
+
+    validates :game_id, uniqueness: true
+    validates :home_score, :away_score,
+              numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :selected_at, presence: true
+    validate :selected_outcome_is_immutable, on: :update
+
+    private
+
+    def selected_outcome_is_immutable
+      return unless IMMUTABLE_ATTRIBUTES.any? { |attribute| will_save_change_to_attribute?(attribute) }
+
+      errors.add(:base, "selected sandbox outcome is immutable")
+    end
+  end
+end

data/app/models/jumbotron/sandbox_projection.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class SandboxProjection < ApplicationRecord
+    belongs_to :source_season, class_name: "Jumbotron::Season", inverse_of: :source_sandbox_projections
+    belongs_to :source_anchor_phase, class_name: "Jumbotron::SeasonPhase"
+    belongs_to :sandbox_season, class_name: "Jumbotron::Season", inverse_of: :sandbox_projection
+    has_many :sandbox_game_mappings, inverse_of: :sandbox_projection, dependent: :restrict_with_exception
+
+    validates :name, presence: true, uniqueness: true, format: { with: /\A[a-z0-9][a-z0-9-]*\z/ }
+    validates :adapter_id, inclusion: { in: %w[sandbox_nfl] }
+    validates :calendar_time_zone, inclusion: { in: ActiveSupport::TimeZone.all.map(&:tzinfo).map(&:name) }
+    validate :anchor_phase_belongs_to_source
+    validate :source_and_sandbox_are_distinct
+
+    private
+
+    def anchor_phase_belongs_to_source
+      return if source_anchor_phase.nil? || source_anchor_phase.season_id == source_season_id
+
+      errors.add(:source_anchor_phase, "must belong to source season")
+    end
+
+    def source_and_sandbox_are_distinct
+      return unless source_season_id == sandbox_season_id
+
+      errors.add(:sandbox_season, "must differ from source season")
+    end
+  end
+end

data/app/models/jumbotron/sandbox_projection_data.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module SandboxProjectionData
+    Team = Data.define(:provider_id, :name, :nickname, :abbreviation)
+    Game = Data.define(
+      :source_game_id,
+      :event_id,
+      :competition_id,
+      :scheduled_at,
+      :season,
+      :season_phase,
+      :week_number,
+      :week_name,
+      :neutral_site,
+      :home,
+      :away,
+      :home_spread,
+      :total,
+      :line_fingerprint,
+      :line_source
+    )
+    Snapshot = Data.define(
+      :games,
+      :source_anchor_date,
+      :target_anchor_date,
+      :date_shift_days,
+      :fingerprint,
+      :start_week
+    )
+  end
+end

data/app/models/jumbotron/season.rb

@@ -7,6 +7,16 @@ module Jumbotron
     has_many :schedule_groups, inverse_of: :season, dependent: :restrict_with_exception
     has_many :games, inverse_of: :season, dependent: :restrict_with_exception
     has_many :provider_identities, as: :target, inverse_of: :target, dependent: :restrict_with_exception
+    has_many :source_sandbox_projections,
+             class_name: "Jumbotron::SandboxProjection",
+             foreign_key: :source_season_id,
+             inverse_of: :source_season,
+             dependent: :restrict_with_exception
+    has_one :sandbox_projection,
+            class_name: "Jumbotron::SandboxProjection",
+            foreign_key: :sandbox_season_id,
+            inverse_of: :sandbox_season,
+            dependent: :restrict_with_exception
 
     validates :name, presence: true
   end

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/adapters/resolve_game_update_policy.rb

@@ -8,6 +8,7 @@ module Jumbotron
           future_game_update
           live_game_update
           interrupted_game_update
+          post_final_game_update
         ].freeze
 
         validate :adapter_id, required: true

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

@@ -20,7 +20,7 @@ module Jumbotron
           end
 
           games = Game.where(league_id: league.id)
-                      .includes(:season, :season_phase, :schedule_group)
+                      .includes(:season, :season_phase, :schedule_group, :game_participants)
                       .select { |game| policy.eligible?(game, now: now) }
 
           context.league = league

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