jumbotron 0.1.1

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class Competition
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :id, type: Support.types.string, required: true
+            field :uid, type: Support.types.string, nullable: true
+            field :date, type: Support.types.string, nullable: true
+            field :start_date, type: Support.types.string, nullable: true
+            field :neutral_site, type: Support.types.boolean, nullable: true
+            field :status, type: Status::Result, required: true
+            field :venue, type: Venue::Result, nullable: true
+            field :competitors, type: Support.types.array(Competitor::Result), required: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "competition")
+
+            Result.build!(
+              id: coerce_id(Support.payload.fetch(payload, "id")),
+              uid: Support.payload.fetch(payload, "uid"),
+              date: Support.payload.fetch(payload, "date"),
+              start_date: Support.payload.fetch(payload, "startDate"),
+              neutral_site: Support.payload.fetch(payload, "neutralSite"),
+              status: Support.nest("status", Support.payload.fetch(payload, "status")) { |raw| Status.call(raw) },
+              venue: Support.nest("venue", Support.payload.fetch(payload, "venue")) { |raw| Venue.call(raw) },
+              competitors: map_competitors(Support.payload.fetch(payload, "competitors"))
+            )
+          end
+
+          def self.coerce_id(raw)
+            return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
+
+            raw.to_s
+          end
+          private_class_method :coerce_id
+
+          def self.map_competitors(raw)
+            if raw.equal?(Support.missing)
+              raise CommandTower::Clients::Errors::DeserializationError.new(
+                message: "competitors is required",
+                details: {
+                  path: "competitors",
+                  expected: "Array",
+                  actual: "missing",
+                  rule: "required",
+                  messages: ["competitors is required"]
+                }
+              )
+            end
+
+            unless raw.is_a?(Array)
+              raise CommandTower::Clients::Errors::DeserializationError.new(
+                message: "competitors must be an Array",
+                details: {
+                  path: "competitors",
+                  expected: "Array",
+                  actual: raw.class.name,
+                  rule: "type",
+                  messages: ["competitors must be an Array"]
+                }
+              )
+            end
+
+            raw.each_with_index.map do |item, index|
+              Competitor.call(item)
+            rescue CommandTower::Clients::Errors::DeserializationError => e
+              raise CommandTower::Deserializers::Clients::Errors.prefix(e, "competitors[#{index}]")
+            end
+          end
+          private_class_method :map_competitors
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/draw_odds.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class DrawOdds
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :money_line, type: Support.types.float, nullable: true
+              field :summary, type: Support.types.string, nullable: true
+              field :value, type: Support.types.float, nullable: true
+              field :handicap, type: Support.types.float, nullable: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "draw_odds")
+
+              Result.build!(
+                money_line: Support.payload.fetch(payload, "moneyLine"),
+                summary: Support.payload.fetch(payload, "summary"),
+                value: Support.payload.fetch(payload, "value"),
+                handicap: Support.payload.fetch(payload, "handicap")
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/get.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class Get
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :count, type: Support.types.integer, nullable: true
+              field :page_index, type: Support.types.integer, nullable: true
+              field :page_size, type: Support.types.integer, nullable: true
+              field :page_count, type: Support.types.integer, nullable: true
+              field :items, type: Support.types.array(Item::Result), required: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "competition_odds")
+              items_raw = Support.payload.fetch(payload, "items")
+
+              if items_raw.equal?(Support.missing)
+                raise CommandTower::Clients::Errors::DeserializationError.new(
+                  message: "items is required",
+                  details: {
+                    path: "items",
+                    expected: "Array",
+                    actual: "missing",
+                    rule: "required",
+                    messages: ["items is required"]
+                  }
+                )
+              end
+
+              unless items_raw.is_a?(Array)
+                raise CommandTower::Clients::Errors::DeserializationError.new(
+                  message: "items must be an Array",
+                  details: {
+                    path: "items",
+                    expected: "Array",
+                    actual: items_raw.class.name,
+                    rule: "type",
+                    messages: ["items must be an Array"]
+                  }
+                )
+              end
+
+              items = items_raw.each_with_index.map do |item, index|
+                Item.call(item)
+              rescue CommandTower::Clients::Errors::DeserializationError => e
+                raise CommandTower::Deserializers::Clients::Errors.prefix(e, "items[#{index}]")
+              end
+
+              Result.build!(
+                count: Support.whole_number(Support.payload.fetch(payload, "count")),
+                page_index: Support.whole_number(Support.payload.fetch(payload, "pageIndex")),
+                page_size: Support.whole_number(Support.payload.fetch(payload, "pageSize")),
+                page_count: Support.whole_number(Support.payload.fetch(payload, "pageCount")),
+                items: items
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/item.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class Item
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :ref, type: Support.types.string, nullable: true
+              field :details, type: Support.types.string, nullable: true
+              field :spread, type: Support.types.float, nullable: true
+              field :over_under, type: Support.types.float, nullable: true
+              field :over_odds, type: Support.types.float, nullable: true
+              field :under_odds, type: Support.types.float, nullable: true
+              field :listed_provider, type: ListedProvider::Result, required: true
+              field :home_team_odds, type: TeamOdds::Result, nullable: true
+              field :away_team_odds, type: TeamOdds::Result, nullable: true
+              field :draw_odds, type: DrawOdds::Result, nullable: true
+              field :open, type: MarketWindow::Result, nullable: true
+              field :current, type: MarketWindow::Result, nullable: true
+              field :close, type: MarketWindow::Result, nullable: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "competition_odds_item")
+
+              Result.build!(
+                ref: Support.payload.fetch(payload, "$ref"),
+                details: Support.payload.fetch(payload, "details"),
+                spread: Support.payload.fetch(payload, "spread"),
+                over_under: Support.payload.fetch(payload, "overUnder"),
+                over_odds: Support.payload.fetch(payload, "overOdds"),
+                under_odds: Support.payload.fetch(payload, "underOdds"),
+                listed_provider: Support.nest("provider", Support.payload.fetch(payload, "provider")) do |raw|
+                  ListedProvider.call(raw)
+                end,
+                home_team_odds: Support.nest("homeTeamOdds", Support.payload.fetch(payload, "homeTeamOdds")) do |raw|
+                  TeamOdds.call(raw)
+                end,
+                away_team_odds: Support.nest("awayTeamOdds", Support.payload.fetch(payload, "awayTeamOdds")) do |raw|
+                  TeamOdds.call(raw)
+                end,
+                draw_odds: Support.nest("drawOdds", Support.payload.fetch(payload, "drawOdds")) do |raw|
+                  DrawOdds.call(raw)
+                end,
+                open: Support.nest("open", Support.payload.fetch(payload, "open")) { |raw| MarketWindow.call(raw) },
+                current: Support.nest(
+                  "current",
+                  Support.payload.fetch(payload, "current")
+                ) { |raw| MarketWindow.call(raw) },
+                close: Support.nest("close", Support.payload.fetch(payload, "close")) { |raw| MarketWindow.call(raw) }
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/listed_provider.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class ListedProvider
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :id, type: Support.types.string, required: true
+              field :name, type: Support.types.string, required: true
+              field :priority, type: Support.types.integer, nullable: true
+              field :ref, type: Support.types.string, nullable: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "listed_provider")
+
+              Result.build!(
+                id: Support.coerce_id(Support.payload.fetch(payload, "id")),
+                name: Support.payload.fetch(payload, "name"),
+                priority: Support.whole_number(Support.payload.fetch(payload, "priority")),
+                ref: Support.payload.fetch(payload, "$ref")
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/market_window.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class MarketWindow
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :over, type: Price::Result, nullable: true
+              field :under, type: Price::Result, nullable: true
+              field :total, type: PointSpread::Result, nullable: true
+              field :draw, type: Price::Result, nullable: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "market_window")
+
+              Result.build!(
+                over: Support.nest("over", Support.payload.fetch(payload, "over")) { |raw| Price.call(raw) },
+                under: Support.nest("under", Support.payload.fetch(payload, "under")) { |raw| Price.call(raw) },
+                total: Support.nest("total", Support.payload.fetch(payload, "total")) { |raw| PointSpread.call(raw) },
+                draw: Support.nest("draw", Support.payload.fetch(payload, "draw")) { |raw| Price.call(raw) }
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/point_spread.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class PointSpread
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :american, type: Support.types.string, nullable: true
+              field :alternate_display_value, type: Support.types.string, nullable: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "point_spread")
+
+              Result.build!(
+                american: Support.payload.fetch(payload, "american"),
+                alternate_display_value: Support.payload.fetch(payload, "alternateDisplayValue")
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/price.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class Price
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :value, type: Support.types.float, nullable: true
+              field :display_value, type: Support.types.string, nullable: true
+              field :alternate_display_value, type: Support.types.string, nullable: true
+              field :decimal, type: Support.types.float, nullable: true
+              field :fraction, type: Support.types.string, nullable: true
+              field :american, type: Support.types.string, nullable: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "price")
+
+              Result.build!(
+                value: Support.payload.fetch(payload, "value"),
+                display_value: Support.payload.fetch(payload, "displayValue"),
+                alternate_display_value: Support.payload.fetch(payload, "alternateDisplayValue"),
+                decimal: Support.payload.fetch(payload, "decimal"),
+                fraction: Support.payload.fetch(payload, "fraction"),
+                american: Support.payload.fetch(payload, "american")
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/side_quote.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class SideQuote
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :favorite, type: Support.types.boolean, nullable: true
+              field :point_spread, type: PointSpread::Result, nullable: true
+              field :spread, type: Price::Result, nullable: true
+              field :money_line, type: Price::Result, nullable: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "side_quote")
+
+              Result.build!(
+                favorite: Support.payload.fetch(payload, "favorite"),
+                point_spread: Support.nest("pointSpread", Support.payload.fetch(payload, "pointSpread")) do |raw|
+                  PointSpread.call(raw)
+                end,
+                spread: Support.nest("spread", Support.payload.fetch(payload, "spread")) { |raw| Price.call(raw) },
+                money_line: Support.nest("moneyLine", Support.payload.fetch(payload, "moneyLine")) do |raw|
+                  Price.call(raw)
+                end
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/team_odds.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module CompetitionOdds
+          class TeamOdds
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :favorite, type: Support.types.boolean, nullable: true
+              field :underdog, type: Support.types.boolean, nullable: true
+              field :money_line, type: Support.types.float, nullable: true
+              field :spread_odds, type: Support.types.float, nullable: true
+              field :open, type: SideQuote::Result, nullable: true
+              field :current, type: SideQuote::Result, nullable: true
+              field :close, type: SideQuote::Result, nullable: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "team_odds")
+
+              Result.build!(
+                favorite: Support.payload.fetch(payload, "favorite"),
+                underdog: Support.payload.fetch(payload, "underdog"),
+                money_line: Support.payload.fetch(payload, "moneyLine"),
+                spread_odds: Support.payload.fetch(payload, "spreadOdds"),
+                open: Support.nest("open", Support.payload.fetch(payload, "open")) { |raw| SideQuote.call(raw) },
+                current: Support.nest(
+                  "current",
+                  Support.payload.fetch(payload, "current")
+                ) { |raw| SideQuote.call(raw) },
+                close: Support.nest("close", Support.payload.fetch(payload, "close")) { |raw| SideQuote.call(raw) }
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class Competitor
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :id, type: Support.types.string, required: true
+            field :uid, type: Support.types.string, nullable: true
+            field :home_away, type: Support.types.string, required: true
+            field :score, type: Support.types.string, nullable: true
+            field :winner, type: Support.types.boolean, nullable: true
+            field :order, type: Support.types.integer, nullable: true
+            field :team, type: Team::Result, required: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "competitor")
+
+            Result.build!(
+              id: coerce_id(Support.payload.fetch(payload, "id")),
+              uid: Support.payload.fetch(payload, "uid"),
+              home_away: Support.payload.fetch(payload, "homeAway"),
+              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) }
+            )
+          end
+
+          def self.coerce_id(raw)
+            return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
+
+            raw.to_s
+          end
+          private_class_method :coerce_id
+
+          def self.coerce_score(raw)
+            return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
+
+            raw.to_s
+          end
+          private_class_method :coerce_score
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class Event
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :id, type: Support.types.string, required: true
+            field :uid, type: Support.types.string, nullable: true
+            field :date, type: Support.types.string, required: true
+            field :name, type: Support.types.string, required: true
+            field :short_name, type: Support.types.string, nullable: true
+            field :season, type: Season::Result, nullable: true
+            field :week, type: Week::Result, nullable: true
+            field :status, type: Status::Result, nullable: true
+            field :competitions, type: Support.types.array(Competition::Result), required: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "event")
+
+            Result.build!(
+              id: coerce_id(Support.payload.fetch(payload, "id")),
+              uid: Support.payload.fetch(payload, "uid"),
+              date: Support.payload.fetch(payload, "date"),
+              name: Support.payload.fetch(payload, "name"),
+              short_name: Support.payload.fetch(payload, "shortName"),
+              season: Support.nest("season", Support.payload.fetch(payload, "season")) { |raw| Season.call(raw) },
+              week: Support.nest("week", Support.payload.fetch(payload, "week")) { |raw| Week.call(raw) },
+              status: Support.nest("status", Support.payload.fetch(payload, "status")) { |raw| Status.call(raw) },
+              competitions: map_competitions(Support.payload.fetch(payload, "competitions"))
+            )
+          end
+
+          def self.coerce_id(raw)
+            return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
+
+            raw.to_s
+          end
+          private_class_method :coerce_id
+
+          def self.map_competitions(raw)
+            if raw.equal?(Support.missing)
+              raise CommandTower::Clients::Errors::DeserializationError.new(
+                message: "competitions is required",
+                details: {
+                  path: "competitions",
+                  expected: "Array",
+                  actual: "missing",
+                  rule: "required",
+                  messages: ["competitions is required"]
+                }
+              )
+            end
+
+            unless raw.is_a?(Array)
+              raise CommandTower::Clients::Errors::DeserializationError.new(
+                message: "competitions must be an Array",
+                details: {
+                  path: "competitions",
+                  expected: "Array",
+                  actual: raw.class.name,
+                  rule: "type",
+                  messages: ["competitions must be an Array"]
+                }
+              )
+            end
+
+            raw.each_with_index.map do |item, index|
+              Competition.call(item)
+            rescue CommandTower::Clients::Errors::DeserializationError => e
+              raise CommandTower::Deserializers::Clients::Errors.prefix(e, "competitions[#{index}]")
+            end
+          end
+          private_class_method :map_competitions
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/scoreboard/get.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module Scoreboard
+          class Get
+            class CalendarPhase < CommandTower::Deserializers::Clients::Result
+              field :season_type, type: Support.types.integer, required: true
+              field :weeks, type: Support.types.array(Support.types.integer), required: true
+            end
+
+            class Result < CommandTower::Deserializers::Clients::Result
+              field :events, type: Support.types.array(Event::Result), required: true
+              field :season_calendar, type: Support.types.array(CalendarPhase), nullable: true
+            end
+
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "scoreboard")
+              events_raw = Support.payload.fetch(payload, "events")
+
+              if events_raw.equal?(Support.missing)
+                raise CommandTower::Clients::Errors::DeserializationError.new(
+                  message: "events is required",
+                  details: {
+                    path: "events",
+                    expected: "Array",
+                    actual: "missing",
+                    rule: "required",
+                    messages: ["events is required"]
+                  }
+                )
+              end
+
+              unless events_raw.is_a?(Array)
+                raise CommandTower::Clients::Errors::DeserializationError.new(
+                  message: "events must be an Array",
+                  details: {
+                    path: "events",
+                    expected: "Array",
+                    actual: events_raw.class.name,
+                    rule: "type",
+                    messages: ["events must be an Array"]
+                  }
+                )
+              end
+
+              events = events_raw.each_with_index.map do |item, index|
+                Event.call(item)
+              rescue CommandTower::Clients::Errors::DeserializationError => e
+                raise CommandTower::Deserializers::Clients::Errors.prefix(e, "events[#{index}]")
+              end
+
+              Result.build!(events: events, season_calendar: parse_season_calendar(payload))
+            end
+
+            def self.parse_season_calendar(payload)
+              leagues = payload["leagues"]
+              return [] unless leagues.is_a?(Array) && leagues.first.is_a?(Hash)
+
+              calendar = leagues.first["calendar"]
+              return [] unless calendar.is_a?(Array)
+
+              calendar.filter_map do |entry|
+                next unless entry.is_a?(Hash)
+
+                season_type = entry["value"].to_i
+                next if season_type <= 0 || season_type == 4
+
+                weeks = Array(entry["entries"]).filter_map do |week|
+                  next unless week.is_a?(Hash)
+
+                  number = week["value"].to_i
+                  number if number.positive?
+                end.uniq
+                next if weeks.empty?
+
+                CalendarPhase.build!(season_type: season_type, weeks: weeks)
+              end
+            end
+            private_class_method :parse_season_calendar
+          end
+        end
+      end
+    end
+  end
+end