jumbotron 0.1.6 → 0.2.0

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

@@ -8,23 +8,34 @@ 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,
-              nickname: participant_input.team_nickname
+              nickname: participant_input.team_nickname,
+              abbreviation: participant_input.team_abbreviation
             ),
             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
@@ -37,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)
@@ -46,16 +67,18 @@ module Jumbotron
         end
 
         def create_new!(team)
-          gp = game.game_participants.create!(
+          attrs = {
             team: team,
             role: participant_input.role,
             score: participant_input.score,
             result: participant_input.result,
             observed_at: observed_at,
             changed_at: observed_at
-          )
+          }.merge(initial_record_attrs)
+          gp = game.game_participants.create!(attrs)
           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)
+          record_create_history!(gp)
           gp
         end
 
@@ -78,11 +101,96 @@ module Jumbotron
             participant.public_send("#{key}=", value)
             material = true
           end
+          material |= apply_record_snapshots!(participant)
           participant.observed_at = observed_at
           participant.changed_at = observed_at if material
           participant.save!
           participant
         end
+
+        def initial_record_attrs
+          summary = participant_input.record_summary
+          return {} if summary.blank?
+
+          attrs = {
+            record_summary_current: summary,
+            record_observed_at: observed_at
+          }
+          if game.lifecycle == "completed"
+            attrs[:record_summary_post_game] = summary
+          elsif game.lifecycle != "cancelled"
+            attrs[:record_summary_entering] = summary
+          end
+          attrs
+        end
+
+        def record_create_history!(participant)
+          %i[
+            record_summary_entering
+            record_summary_current
+            record_summary_post_game
+          ].each do |attr|
+            value = participant.public_send(attr)
+            next if value.blank?
+
+            change_set.record(subject: participant, attribute: attr.to_s, previous: nil, new_value: value)
+          end
+        end
+
+        def apply_record_snapshots!(participant)
+          summary = participant_input.record_summary
+          return false if summary.blank?
+
+          material = false
+          if participant.record_summary_current != summary
+            change_set.record(
+              subject: participant,
+              attribute: "record_summary_current",
+              previous: participant.record_summary_current,
+              new_value: summary
+            )
+            participant.record_summary_current = summary
+            material = true
+          end
+          participant.record_observed_at = observed_at
+
+          if game.lifecycle == "completed"
+            material |= apply_post_game_record!(participant, summary)
+          elsif game.lifecycle != "cancelled"
+            material |= assign_entering_record!(participant, summary)
+          end
+          material
+        end
+
+        def assign_entering_record!(participant, summary) # rubocop:disable Naming/PredicateMethod
+          return false if participant.record_summary_entering == summary
+
+          change_set.record(
+            subject: participant,
+            attribute: "record_summary_entering",
+            previous: participant.record_summary_entering,
+            new_value: summary
+          )
+          participant.record_summary_entering = summary
+          true
+        end
+
+        # Authoritative post-game only: never invent W–L; if total still equals
+        # entering on a completed observation, leave post_game nil (Strategy B).
+        def apply_post_game_record!(participant, summary) # rubocop:disable Naming/PredicateMethod
+          entering = participant.record_summary_entering
+          return false if entering.present? && summary == entering
+          return false if participant.record_summary_post_game == summary
+
+          change_set.record(
+            subject: participant,
+            attribute: "record_summary_post_game",
+            previous: participant.record_summary_post_game,
+            new_value: summary
+          )
+          participant.record_summary_post_game = summary
+          true
+        end
       end
     end
   end

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

@@ -58,6 +58,7 @@ module Jumbotron
             team.changed_at = observed_at
           end
           apply_nickname!(team)
+          apply_abbreviation!(team)
           # key is immutable after assignment — never regenerate from name or provider id
           team.observed_at = observed_at
           team.save!
@@ -68,6 +69,7 @@ module Jumbotron
           team = Team.create!(
             name: team_input.name,
             nickname: team_input.nickname,
+            abbreviation: team_input.abbreviation,
             key: allocate_key!(team_input.name),
             observed_at: observed_at,
             changed_at: observed_at
@@ -82,6 +84,14 @@ module Jumbotron
               new_value: team.nickname
             )
           end
+          if team.abbreviation.present?
+            change_set.record(
+              subject: team,
+              attribute: "abbreviation",
+              previous: nil,
+              new_value: team.abbreviation
+            )
+          end
           team
         end
 
@@ -99,6 +109,20 @@ module Jumbotron
           team.changed_at = observed_at
         end
 
+        def apply_abbreviation!(team)
+          return if team_input.abbreviation.nil?
+          return if team.abbreviation == team_input.abbreviation
+
+          change_set.record(
+            subject: team,
+            attribute: "abbreviation",
+            previous: team.abbreviation,
+            new_value: team_input.abbreviation
+          )
+          team.abbreviation = team_input.abbreviation
+          team.changed_at = observed_at
+        end
+
         def allocate_key!(name)
           base = Jumbotron::TeamKey.normalize(name)
           return base unless Team.exists?(key: base)

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

@@ -52,6 +52,7 @@ module Jumbotron
 
         def update_existing!(venue_id)
           venue = Venue.lock.find(venue_id)
+          material = false
           if venue.name != venue_input.name
             change_set.record(
               subject: venue,
@@ -60,8 +61,10 @@ module Jumbotron
               new_value: venue_input.name
             )
             venue.name = venue_input.name
-            venue.changed_at = observed_at
+            material = true
           end
+          material |= apply_location!(venue)
+          venue.changed_at = observed_at if material
           venue.observed_at = observed_at
           venue.save!
           venue
@@ -70,13 +73,42 @@ module Jumbotron
         def create_new!
           venue = Venue.create!(
             name: venue_input.name,
+            city: venue_input.city,
+            region: venue_input.region,
             observed_at: observed_at,
             changed_at: observed_at
           )
           change_set.record(subject: venue, attribute: "name", previous: nil, new_value: venue.name)
+          if venue.city.present?
+            change_set.record(subject: venue, attribute: "city", previous: nil, new_value: venue.city)
+          end
+          if venue.region.present?
+            change_set.record(subject: venue, attribute: "region", previous: nil, new_value: venue.region)
+          end
           venue
         end
 
+        def apply_location!(venue)
+          material = false
+          {
+            city: venue_input.city,
+            region: venue_input.region
+          }.each do |key, value|
+            next if value.nil?
+            next if venue.public_send(key) == value
+
+            change_set.record(
+              subject: venue,
+              attribute: key.to_s,
+              previous: venue.public_send(key),
+              new_value: value
+            )
+            venue.public_send("#{key}=", value)
+            material = true
+          end
+          material
+        end
+
         def recover_after_race!
           ref = venue_input.provider_identities.first
           identity = ProviderIdentity.find_by!(

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

@@ -61,7 +61,12 @@ module Jumbotron
         def build_venue(venue)
           return if venue.nil?
 
-          Jumbotron::Public::Venue.new(id: venue.id, name: venue.name)
+          Jumbotron::Public::Venue.new(
+            id: venue.id,
+            name: venue.name,
+            city: venue.city,
+            region: venue.region
+          )
         end
 
         def build_participant(participant)
@@ -69,15 +74,28 @@ module Jumbotron
             role: participant.role,
             score: participant.score,
             result: participant.result,
+            record: resolve_presentation_record(participant),
             team: Jumbotron::Public::Team.new(
               id: participant.team.id,
               name: participant.team.name,
               nickname: participant.team.nickname,
-              key: participant.team.key
+              key: participant.team.key,
+              abbreviation: participant.team.abbreviation
             )
           )
         end
 
+        # Lifecycle-resolved game-time record for presentation. Never falls back to
+        # entering when completed post-game is missing.
+        def resolve_presentation_record(participant)
+          case game.lifecycle
+          when "scheduled", "in_progress", "postponed", "suspended"
+            participant.record_summary_entering
+          when "completed"
+            participant.record_summary_post_game
+          end
+        end
+
         def map_currents(lines)
           return [] unless Array(includes).include?(:current_lines)
 

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