jumbotron 0.1.1

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class AssemblePublicSchedule < CommandTower::Services::ApplicationService
+        validate :request, required: true
+        validate :league, required: true
+        validate :public_games, required: false
+        validate :season, required: false
+        validate :season_phase, required: false
+        validate :schedule_group, required: false
+
+        def call
+          context.schedule = Jumbotron::Public::Schedule.new(
+            league: build_league(league),
+            season: build_season(season),
+            season_phase: build_phase(season_phase),
+            group: build_group(schedule_group),
+            starts_at: request.starts_at,
+            ends_at: request.ends_at,
+            games: Array(public_games)
+          )
+        end
+
+        private
+
+        def build_league(record)
+          sport = Jumbotron::Public::Sport.new(id: record.sport.id, name: record.sport.name)
+          Jumbotron::Public::League.new(id: record.id, name: record.name, sport: sport)
+        end
+
+        def build_season(record)
+          return if record.nil?
+
+          Jumbotron::Public::Season.new(
+            id: record.id,
+            name: record.name,
+            starts_on: record.starts_on,
+            ends_on: record.ends_on
+          )
+        end
+
+        def build_phase(record)
+          return if record.nil?
+
+          Jumbotron::Public::SeasonPhase.new(id: record.id, name: record.name)
+        end
+
+        def build_group(record)
+          return if record.nil?
+
+          Jumbotron::Public::ScheduleGroup.new(
+            id: record.id,
+            kind: record.kind,
+            number: record.number,
+            name: record.name
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class DeriveConsensusForGames < CommandTower::Services::ApplicationService
+        validate :current_lines, required: false
+
+        def call
+          derived = Canonical::DeriveConsensusForGames.call(current_lines: current_lines)
+          unless derived.success?
+            context.fail!(application_error: derived.errors.first)
+            return
+          end
+
+          context.consensus_lines = Array(derived.data[:consensus_lines])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class LoadGamesByIds < CommandTower::Services::ApplicationService
+        validate :game_ids, required: false
+
+        def call
+          ids = Array(game_ids)
+          games = Game.includes(ReadGame::ASSOCIATIONS).where(id: ids).to_a
+          by_id = games.index_by(&:id)
+          context.games = ids.filter_map { |id| by_id[id] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class LoadIncludedLines < CommandTower::Services::ApplicationService
+        validate :games, required: false
+        validate :includes, required: false
+
+        def call
+          context.current_lines = []
+          context.consensus_lines = []
+          return if Array(games).empty?
+          return unless needs_currents? || needs_consensus?
+
+          resolved = ResolveCurrentLinesForGames.call(games: games)
+          unless resolved.success?
+            context.fail!(application_error: resolved.errors.first)
+            return
+          end
+          context.current_lines = Array(resolved.data[:current_lines])
+
+          return unless needs_consensus?
+
+          derived = DeriveConsensusForGames.call(current_lines: context.current_lines)
+          unless derived.success?
+            context.fail!(application_error: derived.errors.first)
+            return
+          end
+
+          context.consensus_lines = Array(derived.data[:consensus_lines])
+        end
+
+        private
+
+        def needs_currents?
+          Array(includes).include?(:current_lines)
+        end
+
+        def needs_consensus?
+          includes = Array(self.includes)
+          includes.include?(:consensus) || includes.include?(:consensus_constituents)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class MapPublicConsensusLines < CommandTower::Services::ApplicationService
+        validate :consensus_lines, required: false
+        validate :current_lines, required: false
+        validate :include_constituents, required: false
+
+        def call
+          context.public_consensus_lines = Array(consensus_lines).map do |line|
+            Jumbotron::Public::ConsensusLine.new(
+              game_id: line.game_id,
+              market: line.market,
+              outcome: line.outcome,
+              line_value: line.line_value,
+              constituent_count: line.constituent_count,
+              observed_at: observed_at_for(line),
+              constituents: constituents_for(line)
+            )
+          end
+        end
+
+        private
+
+        def observed_at_for(line)
+          matching = Array(current_lines).select do |current|
+            current.game_id == line.game_id && current.market == line.market && current.outcome == line.outcome
+          end
+          matching.map(&:observed_at).compact.max
+        end
+
+        def constituents_for(line)
+          return [] unless include_constituents
+
+          Array(line.constituents).map do |constituent|
+            Jumbotron::Public::ConsensusConstituent.new(bookmaker_id: constituent.bookmaker_id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class MapPublicCurrentLines < CommandTower::Services::ApplicationService
+        validate :current_lines, required: false
+
+        def call
+          context.public_current_lines = Array(current_lines).map do |line|
+            Jumbotron::Public::CurrentLine.new(
+              game_id: line.game_id,
+              bookmaker_id: line.bookmaker_id,
+              bookmaker_name: line.bookmaker_name,
+              market: line.market,
+              outcome: line.outcome,
+              line_value: line.line_value,
+              price_american: line.price_american,
+              observed_at: line.observed_at,
+              changed_at: line.changed_at
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class ReadGame < CommandTower::Services::ApplicationService
+        ASSOCIATIONS = [
+          :venue,
+          :season_phase,
+          :schedule_group,
+          { league: :sport, season: :league, game_participants: :team }
+        ].freeze
+
+        validate :game_id, required: true
+
+        def call
+          game = Game.includes(ASSOCIATIONS).find_by(id: game_id)
+          if game.nil?
+            context.fail!(
+              application_error: Jumbotron::Errors::Public::NotFoundError.new(
+                details: { code: "game_not_found", message: "game was not found" }
+              )
+            )
+            return
+          end
+
+          context.game = game
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class ReadSchedule < CommandTower::Services::ApplicationService
+        validate :request, required: true
+
+        def call
+          league = resolve_league
+          return if context.failure?
+
+          if league.nil?
+            not_found("league_not_found", "league was not found")
+            return
+          end
+
+          season = resolve_season(league)
+          return if context.failure?
+
+          phase = resolve_phase(season)
+          return if context.failure?
+
+          group = resolve_group(season, phase)
+          return if context.failure?
+
+          games = load_games(league, season, phase, group)
+          context.league = league
+          context.season = season
+          context.season_phase = phase
+          context.schedule_group = group
+          context.games = games
+        end
+
+        private
+
+        def resolve_league
+          return League.includes(:sport).find_by(id: request.league_id) if request.league_id.present?
+
+          sport = Sport.where("LOWER(name) = ?", request.sport.to_s.downcase).first
+          return if sport.nil?
+
+          sport.leagues.where("LOWER(name) = ?", request.league.to_s.downcase).first
+        end
+
+        def resolve_season(league)
+          return if request.season_id.blank? && request.season.blank?
+
+          season =
+            if request.season_id.present?
+              Season.find_by(id: request.season_id, league_id: league.id)
+            else
+              league.seasons.where("LOWER(name) = ?", request.season.to_s.downcase).first
+            end
+          not_found("season_not_found", "season was not found") if season.nil?
+          season
+        end
+
+        def resolve_phase(season)
+          return if request.season_phase.blank?
+
+          if season.nil?
+            not_found("season_not_found", "season was not found")
+            return
+          end
+
+          phase = season.season_phases.where("LOWER(name) = ?", request.season_phase.to_s.downcase).first
+          not_found("season_phase_not_found", "season phase was not found") if phase.nil?
+          phase
+        end
+
+        def resolve_group(season, phase)
+          return if request.schedule_group_id.blank? && request.group.blank?
+
+          group =
+            if request.schedule_group_id.present?
+              ScheduleGroup.find_by(id: request.schedule_group_id)
+            else
+              if season.nil? || phase.nil?
+                not_found("schedule_group_not_found", "schedule group was not found")
+                return
+              end
+              ScheduleGroup.find_by(
+                season_id: season.id,
+                season_phase_id: phase.id,
+                kind: request.group[:kind],
+                number: request.group[:number]
+              )
+            end
+          not_found("schedule_group_not_found", "schedule group was not found") if group.nil?
+          group
+        end
+
+        def load_games(league, season, phase, group)
+          relation = Game.includes(ReadGame::ASSOCIATIONS).where(league_id: league.id)
+          relation = relation.where(season_id: season.id) if season
+          relation = relation.where(season_phase_id: phase.id) if phase
+          if group
+            relation = relation.where(schedule_group_id: group.id)
+          elsif request.starts_at && request.ends_at
+            relation = relation.where(scheduled_at: request.starts_at..request.ends_at)
+          end
+          relation.order(:scheduled_at, :id).to_a
+        end
+
+        def not_found(code, message)
+          context.fail!(
+            application_error: Jumbotron::Errors::Public::NotFoundError.new(
+              details: { code: code, message: message }
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      # Lists observed ScheduleGroups for a resolved SeasonPhase.
+      # Completeness is always :incomplete until a dedicated authoritative catalog exists.
+      class ReadScheduleGroups < CommandTower::Services::ApplicationService
+        validate :request, required: true
+
+        def call
+          league = resolve_league
+          return if context.failure?
+
+          if league.nil?
+            not_found("league_not_found", "league was not found")
+            return
+          end
+
+          season = resolve_season(league)
+          return if context.failure?
+          return if season.nil?
+
+          phase = resolve_phase(season)
+          return if context.failure?
+          return if phase.nil?
+
+          records = load_groups(season, phase)
+          groups = records.map { |record| build_group(record) }
+
+          context.schedule_groups = Jumbotron::Public::ScheduleGroupEnumeration.new(
+            groups: groups,
+            completeness: :incomplete
+          )
+        end
+
+        private
+
+        def resolve_league
+          return League.includes(:sport).find_by(id: request.league_id) if request.league_id.present?
+
+          sport = Sport.where("LOWER(name) = ?", request.sport.to_s.downcase).first
+          return if sport.nil?
+
+          sport.leagues.where("LOWER(name) = ?", request.league.to_s.downcase).first
+        end
+
+        def resolve_season(league)
+          season =
+            if request.season_id.present?
+              Season.find_by(id: request.season_id, league_id: league.id)
+            else
+              league.seasons.where("LOWER(name) = ?", request.season.to_s.downcase).first
+            end
+          not_found("season_not_found", "season was not found") if season.nil?
+          season
+        end
+
+        def resolve_phase(season)
+          phase = season.season_phases.where("LOWER(name) = ?", request.season_phase.to_s.downcase).first
+          not_found("season_phase_not_found", "season phase was not found") if phase.nil?
+          phase
+        end
+
+        def load_groups(season, phase)
+          relation = ScheduleGroup.where(season_id: season.id, season_phase_id: phase.id)
+          relation = relation.where(kind: request.kind) if request.kind.present?
+          relation.order(Arel.sql("number IS NULL, number ASC, name ASC, id ASC")).to_a
+        end
+
+        def build_group(record)
+          Jumbotron::Public::ScheduleGroup.new(
+            id: record.id,
+            kind: record.kind,
+            number: record.number,
+            name: record.name
+          )
+        end
+
+        def not_found(code, message)
+          context.fail!(
+            application_error: Jumbotron::Errors::Public::NotFoundError.new(
+              details: { code: code, message: message }
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Public
+      class ResolveCurrentLinesForGames < CommandTower::Services::ApplicationService
+        validate :games, required: false
+
+        def call
+          resolved = Canonical::ResolveCurrentLinesForGames.call(game_ids: Array(games).map(&:id))
+          unless resolved.success?
+            context.fail!(application_error: resolved.errors.first)
+            return
+          end
+
+          context.current_lines = Array(resolved.data[:current_lines])
+        end
+      end
+    end
+  end
+end

data/app/synchronization/jumbotron/synchronization/lease.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Jumbotron
+  module Synchronization
+    class UnsupportedStoreError < StandardError; end
+
+    # Narrow single-writer lease. Contract is backend-neutral; atomic acquire/release
+    # require a capable cache/store (MemoryStore or RedisCacheStore). NullStore is rejected.
+    class Lease
+      DEFAULT_TTL_SECONDS = 120
+      KEY_PREFIX = "jumbotron:synchronization:lease"
+
+      COMPARE_AND_DELETE_LUA = <<~LUA
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("del", KEYS[1])
+        else
+          return 0
+        end
+      LUA
+
+      Result = Data.define(:acquired, :token, :scope) do
+        def acquired?
+          acquired
+        end
+      end
+
+      def self.scope(adapter_id:, endpoint:, acquisition:)
+        parts = [
+          adapter_id.to_s,
+          endpoint.to_s,
+          *normalized_acquisition_parts(acquisition)
+        ]
+        parts.join(":")
+      end
+
+      def self.normalized_acquisition_parts(acquisition)
+        hash = acquisition.respond_to?(:to_h) ? acquisition.to_h : {}
+        hash = hash.transform_keys(&:to_s)
+        hash.keys.sort.map { |key| hash[key].to_s }
+      end
+
+      def initialize(store: Rails.cache, ttl: DEFAULT_TTL_SECONDS)
+        @store = store
+        @ttl = Integer(ttl)
+        assert_capable_store!
+      end
+
+      def acquire(scope)
+        assert_capable_store!
+        token = SecureRandom.uuid
+        key = cache_key(scope)
+        written = store.write(
+          key,
+          token,
+          unless_exist: true,
+          expires_in: ttl,
+          raw: true
+        )
+        if written
+          Result.new(acquired: true, token: token, scope: scope)
+        else
+          Result.new(acquired: false, token: nil, scope: scope)
+        end
+      end
+
+      def release(scope, token:)
+        assert_capable_store!
+        return false if token.nil?
+
+        compare_and_delete(cache_key(scope), token.to_s)
+      end
+
+      private
+
+      attr_reader :store, :ttl
+
+      def cache_key(scope)
+        "#{KEY_PREFIX}:#{scope}"
+      end
+
+      def assert_capable_store!
+        case store
+        when ActiveSupport::Cache::NullStore
+          raise UnsupportedStoreError,
+                "ActiveSupport::Cache::NullStore cannot satisfy Synchronization::Lease"
+        when ActiveSupport::Cache::MemoryStore,
+             ActiveSupport::Cache::RedisCacheStore
+          nil
+        else
+          raise UnsupportedStoreError,
+                "#{store.class} cannot satisfy Synchronization::Lease atomic acquire/release"
+        end
+      end
+
+      def compare_and_delete(key, token)
+        case store
+        when ActiveSupport::Cache::MemoryStore
+          memory_compare_and_delete(key, token)
+        when ActiveSupport::Cache::RedisCacheStore
+          redis_compare_and_delete(key, token)
+        else
+          raise UnsupportedStoreError, "#{store.class} cannot ownership-safe release"
+        end
+      end
+
+      def memory_compare_and_delete(key, token)
+        store.send(:synchronize) do
+          current = store.read(key, raw: true)
+          next false unless current == token
+
+          store.delete(key)
+          true
+        end
+      end
+
+      def redis_compare_and_delete(key, token)
+        normalized = store.send(:normalize_key, key, store.options)
+        store.redis.then do |redis|
+          deleted = redis.call("eval", COMPARE_AND_DELETE_LUA, 1, normalized, token)
+          deleted.to_i.positive?
+        end
+      end
+    end
+  end
+end