jumbotron 0.1.1

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class ResolveLineUpdatePolicy < CommandTower::Services::ApplicationService
+        LINE_POLICY_TYPES = %i[
+          future_line_update
+          live_line_update
+          interrupted_line_update
+        ].freeze
+
+        validate :adapter_id, required: true
+        validate :policy_id, required: true
+
+        def call
+          Jumbotron::Adapters::Registry.ensure_loaded!
+          adapter = Jumbotron::Adapters::Registry.find(adapter_id)
+          if adapter.nil?
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::UnknownAdapterError.new(
+                details: { adapter_id: adapter_id }
+              )
+            )
+            return
+          end
+
+          unless adapter.registered?
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::NotRegisteredError.new(
+                details: { adapter: adapter.to_s }
+              )
+            )
+            return
+          end
+
+          key = policy_id.to_sym
+          if adapter.discovery_ids.include?(key)
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::DiscoveryNotExecutableError.new(
+                details: { policy_id: policy_id }
+              )
+            )
+            return
+          end
+
+          policy = lookup_policy(adapter, key)
+          return if policy.nil?
+
+          unless LINE_POLICY_TYPES.include?(policy.type)
+            context.fail!(application_error: Jumbotron::Errors::Adapters::InvalidLinePolicyTypeError.new)
+            return
+          end
+
+          context.adapter = adapter
+          context.policy = policy
+        end
+
+        private
+
+        def lookup_policy(adapter, key)
+          adapter.policy(key)
+        rescue Jumbotron::Adapters::UnknownPolicyError
+          context.fail!(
+            application_error: Jumbotron::Errors::Adapters::UnknownPolicyError.new(
+              details: { policy_id: policy_id }
+            )
+          )
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class SelectEligibleGames < CommandTower::Services::ApplicationService
+        validate :adapter, required: true
+        validate :policy, required: true
+        validate :now, required: true
+
+        def call
+          league = find_league
+          if league.nil?
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::LeagueNotFoundError.new(
+                details: { league_id: "#{adapter.sport}/#{adapter.league}" }
+              )
+            )
+            return
+          end
+
+          games = Game.where(league_id: league.id)
+                      .includes(:season, :season_phase, :schedule_group)
+                      .select { |game| policy.eligible?(game, now: now) }
+
+          context.league = league
+          context.games = games
+        end
+
+        private
+
+        def find_league
+          sport = Sport.where("LOWER(name) = ?", adapter.sport.downcase).first
+          return if sport.nil?
+
+          sport.leagues.where("LOWER(name) = ?", adapter.league.downcase).first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Adapters
+      class ValidateSyncRequest < CommandTower::Services::ApplicationService
+        validate :adapter, required: true
+        validate :endpoint, required: true
+        validate :league_id, required: true
+
+        def call
+          unless adapter.respond_to?(:registered?) && adapter.respond_to?(:operation) &&
+                 adapter.respond_to?(:endpoints)
+            context.fail!(application_error: Jumbotron::Errors::Adapters::InvalidAdapterError.new)
+            return
+          end
+
+          unless adapter.registered?
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::NotRegisteredError.new(
+                details: { adapter: adapter.to_s }
+              )
+            )
+            return
+          end
+
+          unless adapter.endpoints.key?(endpoint.to_sym)
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::UnknownEndpointError.new(
+                details: { endpoint: endpoint }
+              )
+            )
+            return
+          end
+
+          league = Jumbotron::League.find_by(id: league_id)
+          if league.nil?
+            context.fail!(
+              application_error: Jumbotron::Errors::Adapters::LeagueNotFoundError.new(
+                details: { league_id: league_id }
+              )
+            )
+            return
+          end
+
+          context.league = league
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class AttachProviderIdentities < CommandTower::Services::ApplicationService
+        validate :target, required: true
+        validate :refs, is_a: Array, required: true
+
+        def call
+          conflict = refs.find { |ref| conflicting_identity?(ref) }
+          if conflict
+            context.fail!(
+              application_error: Jumbotron::Errors::Canonical::ProviderIdentityConflictError.new
+            )
+            return
+          end
+
+          refs.each { |ref| ensure_identity!(ref) }
+          context.target = target
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+
+        private
+
+        def conflicting_identity?(ref)
+          identity = find_identity(ref)
+          return false unless identity
+
+          identity.target_type != target.class.name || identity.target_id != target.id
+        end
+
+        def ensure_identity!(ref)
+          return if find_identity(ref)
+
+          ProviderIdentity.create!(
+            provider: ref.provider,
+            object_namespace: ref.namespace,
+            provider_id: ref.id,
+            target: target
+          )
+        end
+
+        def find_identity(ref)
+          ProviderIdentity.find_by(
+            provider: ref.provider,
+            object_namespace: ref.namespace,
+            provider_id: ref.id
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class DeriveConsensusForGames < CommandTower::Services::ApplicationService
+        validate :current_lines, required: false
+
+        def call
+          grouped = Array(current_lines).group_by(&:game_id)
+          context.consensus_lines = grouped.flat_map do |game_id, lines|
+            DeriveConsensusLine.from_current_lines(game_id: game_id, current_lines: lines)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Jumbotron
+  module Services
+    module Canonical
+      class DeriveConsensusLine < CommandTower::Services::ApplicationService
+        CONSENSUS_MARKETS = %w[spread total].freeze
+        LIVE_ODDS_NAME = /\blive odds\b/i
+
+        validate :game, required: true
+        validate :current_lines, required: false
+
+        def call
+          currents = current_lines
+          if currents.nil?
+            resolved = ResolveCurrentLines.call(game: game)
+            unless resolved.success?
+              context.fail!(application_error: resolved.errors.first)
+              return
+            end
+            currents = Array(resolved.data[:current_lines])
+          end
+
+          context.consensus_lines = self.class.from_current_lines(
+            game_id: game.id,
+            current_lines: currents
+          )
+        end
+
+        def self.from_current_lines(game_id:, current_lines:)
+          currents = Array(current_lines)
+          latest_at = currents.filter_map(&:observed_at).max
+          eligible = currents.select { |line| eligible?(line, latest_at) }
+          eligible.group_by { |line| [line.market, line.outcome] }.map do |(_key, members)|
+            to_consensus(game_id, members)
+          end
+        end
+
+        def self.eligible?(line, latest_at)
+          return false unless CONSENSUS_MARKETS.include?(line.market)
+          return false if line.line_value.nil?
+          return false if line.bookmaker_name.to_s.match?(LIVE_ODDS_NAME)
+          return false if latest_at.nil?
+
+          line.observed_at == latest_at
+        end
+
+        def self.to_consensus(game_id, members)
+          values = members.map { |line| BigDecimal(line.line_value.to_s) }
+          mean = values.sum / values.size
+          Jumbotron::Canonical::ConsensusLine.new(
+            game_id: game_id,
+            market: members.first.market,
+            outcome: members.first.outcome,
+            line_value: mean,
+            constituent_count: members.size,
+            constituents: members.map do |line|
+              Jumbotron::Canonical::ConsensusConstituent.new(
+                line_observation_id: line.line_observation_id,
+                bookmaker_id: line.bookmaker_id
+              )
+            end
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class EnsureBookmaker < CommandTower::Services::ApplicationService
+        validate :identity, required: true
+        validate :name, is_a: String, required: true
+        validate :observed_at, required: true
+
+        def call
+          existing = find_identity
+          bookmaker = if existing&.target.is_a?(Bookmaker)
+                        update_existing!(existing.target)
+                      else
+                        create_new!
+                      end
+
+          attach = AttachProviderIdentities.call(target: bookmaker, refs: [identity])
+          unless attach.success?
+            context.fail!(application_error: attach.errors.first)
+            return
+          end
+
+          context.bookmaker = bookmaker
+          context.created = existing.nil?
+        rescue ActiveRecord::RecordNotUnique
+          recovered = find_identity
+          context.bookmaker = update_existing!(recovered.target)
+          context.created = false
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+
+        private
+
+        def find_identity
+          ProviderIdentity.find_by(
+            provider: identity.provider,
+            object_namespace: identity.namespace,
+            provider_id: identity.id
+          )
+        end
+
+        def create_new!
+          Bookmaker.create!(
+            name: name,
+            observed_at: observed_at,
+            changed_at: observed_at
+          )
+        end
+
+        def update_existing!(bookmaker)
+          locked = Bookmaker.lock.find(bookmaker.id)
+          if locked.name != name
+            locked.name = name
+            locked.changed_at = observed_at
+          end
+          locked.observed_at = observed_at
+          locked.save!
+          locked
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class EnsureScheduleGroup < CommandTower::Services::ApplicationService
+        validate :season, required: true
+        validate :season_phase, required: false
+        validate :schedule_group_input, required: false
+
+        def call
+          context.schedule_group = resolve_group
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+
+        private
+
+        def resolve_group
+          input = schedule_group_input
+          return if input.nil?
+
+          group = ScheduleGroup.find_or_initialize_by(
+            season_id: season.id,
+            season_phase_id: season_phase&.id,
+            kind: input.kind.to_s,
+            name: input.name.to_s
+          )
+          group.number = input.number
+          group.save!
+          group
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class EnsureSeason < CommandTower::Services::ApplicationService
+        validate :league, required: true
+        validate :year, required: true
+
+        def call
+          context.season = Season.find_or_create_by!(league_id: league.id, name: year.to_s)
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class EnsureSeasonPhase < CommandTower::Services::ApplicationService
+        validate :season, required: true
+        validate :phase_key, required: true
+
+        def call
+          context.season_phase = SeasonPhase.find_or_create_by!(season_id: season.id, name: phase_key.to_s)
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Jumbotron
+  module Services
+    module Canonical
+      class PersistLineObservations < CommandTower::Services::ApplicationService
+        validate :ingest, required: true
+
+        def call
+          unless ingest.is_a?(Jumbotron::Canonical::LineIngestInput)
+            context.fail!(
+              application_error: Jumbotron::Errors::Canonical::InvalidLineIngestError.new(
+                details: { message: "ingest must be Canonical::LineIngestInput" }
+              )
+            )
+            return
+          end
+
+          if ingest.game_identities.blank? || ingest.provider.blank? || ingest.adapter_scope.blank? ||
+             ingest.observed_at.blank?
+            context.fail!(
+              application_error: Jumbotron::Errors::Canonical::InvalidLineIngestError.new(
+                details: { message: "provider, adapter_scope, observed_at, and game_identities are required" }
+              )
+            )
+            return
+          end
+
+          created = 0
+          updated = 0
+          bookmakers_created = 0
+          resolved_ids = {}
+
+          transaction do
+            game = resolve_game!
+            batch = ObservationBatch.create!(
+              provider: ingest.provider,
+              adapter_scope: ingest.adapter_scope,
+              observed_at: ingest.observed_at,
+              metadata: {}
+            )
+
+            ingest.observations.each do |row|
+              bookmaker = resolved_ids[bookmaker_key(row.bookmaker_identity)]
+              unless bookmaker
+                ensured = EnsureBookmaker.call(
+                  identity: row.bookmaker_identity,
+                  name: row.bookmaker_name,
+                  observed_at: ingest.observed_at
+                )
+                fail_transaction!(ensured) unless ensured.success?
+
+                bookmaker = ensured.data[:bookmaker]
+                resolved_ids[bookmaker_key(row.bookmaker_identity)] = bookmaker
+                bookmakers_created += 1 if ensured.data[:created]
+              end
+
+              case persist_row!(game, bookmaker, batch, row)
+              when :created
+                created += 1
+              when :updated
+                updated += 1
+              end
+            end
+
+            context.observation_batch_id = batch.id
+            context.bookmakers_resolved = resolved_ids.size
+            context.bookmakers_created = bookmakers_created
+            context.observations_created = created
+            context.observations_updated = updated
+          end
+        rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::MutationFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+
+        private
+
+        def resolve_game!
+          ingest.game_identities.each do |ref|
+            identity = ProviderIdentity.find_by(
+              provider: ref.provider,
+              object_namespace: ref.namespace,
+              provider_id: ref.id
+            )
+            return identity.target if identity&.target.is_a?(Game)
+          end
+
+          fail_transaction!(Jumbotron::Errors::Canonical::GameNotFoundError.new)
+        end
+
+        def persist_row!(game, bookmaker, batch, row)
+          existing = LineObservation.lock.where(
+            game_id: game.id,
+            bookmaker_id: bookmaker.id,
+            market: row.market,
+            outcome: row.outcome,
+            source: row.source
+          ).order(observed_at: :desc, id: :desc).first
+
+          if existing && same_values?(existing, row)
+            existing.observed_at = ingest.observed_at
+            existing.save!
+            return :updated
+          end
+
+          LineObservation.create!(
+            game: game,
+            bookmaker: bookmaker,
+            observation_batch: batch,
+            market: row.market,
+            outcome: row.outcome,
+            source: row.source,
+            line_value: row.line_value,
+            price_american: row.price_american,
+            observed_at: ingest.observed_at,
+            changed_at: ingest.observed_at
+          )
+          :created
+        end
+
+        def same_values?(existing, row)
+          same_decimal?(existing.line_value, row.line_value) &&
+            existing.price_american == row.price_american
+        end
+
+        def same_decimal?(left, right)
+          return true if left.nil? && right.nil?
+          return false if left.nil? || right.nil?
+
+          BigDecimal(left.to_s) == BigDecimal(right.to_s)
+        end
+
+        def bookmaker_key(identity)
+          [identity.provider, identity.namespace, identity.id]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class RecordObservationEvidence < CommandTower::Services::ApplicationService
+        validate :change_set, required: true
+        validate :provider, is_a: String, required: true
+        validate :adapter_scope, is_a: String, required: true
+        validate :observed_at, required: true
+
+        def call
+          unless change_set.any?
+            context.observation_batch_id = nil
+            context.historical_change_count = 0
+            return
+          end
+
+          batch = ObservationBatch.create!(
+            provider: provider,
+            adapter_scope: adapter_scope,
+            observed_at: observed_at,
+            metadata: {}
+          )
+
+          change_set.each do |entry|
+            HistoricalChange.create!(
+              observation_batch: batch,
+              subject_type: entry.subject.class.name,
+              subject_id: entry.subject.id,
+              attribute_name: entry.attribute,
+              previous_value: entry.previous,
+              new_value: entry.new_value,
+              observed_at: observed_at,
+              provider: provider
+            )
+          end
+
+          context.observation_batch_id = batch.id
+          context.historical_change_count = change_set.size
+        rescue ActiveRecord::RecordInvalid => e
+          context.fail!(
+            application_error: Jumbotron::Errors::Canonical::ObservationEvidenceFailedError.new(
+              details: { message: e.message }
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Services
+    module Canonical
+      class ResolveCurrentLines < CommandTower::Services::ApplicationService
+        validate :game, required: true
+
+        def call
+          resolved = ResolveCurrentLinesForGames.call(game_ids: [game.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