Planned disruptions logic

config/config.exs

@@ -25,6 +25,7 @@ config :dotcom, :redix, Redix
 config :dotcom, :redix_pub_sub, Redix.PubSub
 
 config :dotcom, :repo_modules,
+  alerts: Alerts.Repo,
   predictions: Predictions.Repo,
   route_patterns: RoutePatterns.Repo,
   routes: Routes.Repo,

config/test.exs

@@ -20,6 +20,7 @@ config :dotcom, :mbta_api_module, MBTA.Api.Mock
 config :dotcom, :location_service, LocationService.Mock
 
 config :dotcom, :repo_modules,
+  alerts: Alerts.Repo.Mock,
   predictions: Predictions.Repo.Mock,
   route_patterns: RoutePatterns.Repo.Mock,
   routes: Routes.Repo.Mock,

lib/alerts/repo.ex

@@ -1,6 +1,9 @@
 defmodule Alerts.Repo do
   alias Alerts.{Alert, Banner, Priority}
   alias Alerts.Cache.Store
+  alias Alerts.Repo.Behaviour
+
+  @behaviour Behaviour
 
   @spec all(DateTime.t()) :: [Alert.t()]
   def all(now) do
@@ -17,7 +20,7 @@ defmodule Alerts.Repo do
     Store.alert(id)
   end
 
-  @spec by_route_ids([String.t()], DateTime.t()) :: [Alert.t()]
+  @impl Behaviour
   def by_route_ids([], _now) do
     []
   end

lib/alerts/repo/behaviour.ex

@@ -0,0 +1,12 @@
+defmodule Alerts.Repo.Behaviour do
+  @moduledoc """
+  Behaviour for the Alerts repo.
+  """
+
+  alias Alerts.Alert
+
+  @doc """
+  Return all alerts for the given route ids.
+  """
+  @callback by_route_ids([String.t()], DateTime.t()) :: [Alert.t()]
+end

lib/dotcom/alerts.ex

@@ -0,0 +1,23 @@
+defmodule Dotcom.Alerts do
+  @moduledoc """
+  A collection of functions that help to work with alerts in a unified way.
+  """
+
+  alias Alerts.Alert
+
+  @service_impacting_effects [:delay, :shuttle, :suspension, :station_closure]
+
+  @doc """
+  Does the alert have an effect that is considered service-impacting?
+  """
+  @spec service_impacting_alert?(Alert.t()) :: boolean()
+  def service_impacting_alert?(%Alert{effect: effect}) do
+    effect in @service_impacting_effects
+  end
+
+  @doc """
+  Returns a list of the alert effects that are considered service-impacting.
+  """
+  @spec service_impacting_effects() :: [atom()]
+  def service_impacting_effects(), do: @service_impacting_effects
+end

lib/dotcom/alerts/disruptions/subway.ex

@@ -0,0 +1,55 @@
+defmodule Dotcom.Alerts.Disruptions.Subway do
+  @moduledoc """
+  Disruptions are alerts that have `service_impacting_effects` grouped by `service_range`.
+  """
+
+  import Dotcom.Alerts, only: [service_impacting_alert?: 1]
+  import Dotcom.Routes, only: [subway_route_ids: 0]
+  import Dotcom.Utils.ServiceDateTime, only: [service_range: 1]
+
+  alias Alerts.Alert
+  alias Dotcom.Utils
+
+  @alerts_repo Application.compile_env!(:dotcom, :repo_modules)[:alerts]
+
+  @doc """
+  Disruptions that occur any time after today's service range.
+  """
+  @spec future_disruptions() :: %{Utils.ServiceDateTime.named_service_range() => [Alert.t()]}
+  def future_disruptions() do
+    disruption_groups() |> Map.take([:later_this_week, :next_week, :after_next_week])
+  end
+
+  @doc """
+  Disruptions that occur during today's service range.
+  """
+  @spec todays_disruptions() :: %{today: [Alert.t()]}
+  def todays_disruptions() do
+    disruption_groups() |> Map.take([:today])
+  end
+
+  # Groups all disruption alerts by service range.
+  #
+  # 1. Gets all alerts for subway routes.
+  # 2. Filters out non-service-impacting alerts
+  # 3. Groups them according to service range.
+  defp disruption_groups() do
+    subway_route_ids()
+    |> @alerts_repo.by_route_ids(Utils.DateTime.now())
+    |> Enum.filter(&service_impacting_alert?/1)
+    |> Enum.reduce(%{}, &group_alerts/2)
+  end
+
+  # Looks at every active period for an alert and groups that alert by service range.
+  # Alerts can overlap service ranges, in which case we want them to appear in both.
+  defp group_alerts(alert, groups) do
+    alert
+    |> Map.get(:active_period)
+    |> Enum.map(fn {start, stop} -> [service_range(start), service_range(stop)] end)
+    |> List.flatten()
+    |> Enum.uniq()
+    |> Enum.reduce(groups, fn service_range, groups ->
+      Map.update(groups, service_range, [alert], &(&1 ++ [alert]))
+    end)
+  end
+end

lib/dotcom/routes.ex

@@ -0,0 +1,13 @@
+defmodule Dotcom.Routes do
+  @moduledoc """
+  A collection of functions that help to work with routes in a unified way.
+  """
+
+  @subway_route_ids ["Blue", "Green", "Orange", "Red"]
+
+  @doc """
+  Returns a list of route ids for all subway routes.
+  """
+  @spec subway_route_ids() :: [String.t()]
+  def subway_route_ids(), do: @subway_route_ids
+end

lib/dotcom/system_status/alerts.ex

@@ -5,13 +5,9 @@ defmodule Dotcom.SystemStatus.Alerts do
   belong in the main `Alerts` module.
   """
 
+  import Dotcom.Alerts, only: [service_impacting_alert?: 1]
+
   @type service_effect_t :: :delay | :shuttle | :suspension | :station_closure
-  @service_effects [:delay, :shuttle, :suspension, :station_closure]
-  @doc """
-  Returns a list of the alert effects that are considered
-  service-impacting.
-  """
-  def service_effects(), do: @service_effects
 
   @doc """
   Returns `true` if the alert is active at some point during the day
@@ -92,7 +88,7 @@ defmodule Dotcom.SystemStatus.Alerts do
   }
   """
   def filter_relevant(alerts) do
-    alerts |> Enum.filter(fn %{effect: effect} -> effect in @service_effects end)
+    alerts |> Enum.filter(&service_impacting_alert?/1)
   end
 
   # Returns true if the alert (as signified by the active_period_start provided)

lib/dotcom/utils/date_time.ex

@@ -39,6 +39,8 @@ defmodule Dotcom.Utils.DateTime do
   Timex will return an error if the time occurs when we "spring-forward" in DST transitions.
   That is because one hour does not occur--02:00:00am to 03:00:00am.
   In that case, we set the time to 03:00:00am.
+
+  If we are given something tha tis not a DateTime, AmbiguousDateTime, or an error tuple, we log the input and return `now`.
   """
   @impl Behaviour
   def coerce_ambiguous_date_time(%DateTime{} = date_time), do: date_time

livebooks/planned-disruptions.livemd

@@ -0,0 +1,124 @@
+# Planned Disruptions
+
+## Section
+
+```elixir
+defmodule Dotcom.PlannedDisruptions.Display do
+  @moduledoc false
+
+  def buckets_to_output(buckets) do
+    Enum.each(buckets, &bucket_to_output/1)
+  end
+
+  defp alert_to_lines(alert) do
+    Enum.map(alert.informed_entity.entities, & &1.route)
+    |> Enum.uniq()
+    |> Enum.sort()
+    |> Enum.join(" / ")
+  end
+
+  def alert_to_output(alert) do
+    {start, stop} = time_range(alert.active_period)
+    lines = alert_to_lines(alert)
+    effect = alert.effect |> Atom.to_string() |> String.upcase()
+
+    IO.puts("#{lines} [#{effect}] #{format_date(start)}-#{format_date(stop)}")
+    IO.puts("---------------")
+    IO.puts(alert.header)
+    IO.puts("\n")
+  end
+
+  defp bucket_to_output({key, alerts}) do
+    key |> Atom.to_string() |> Recase.to_title() |> IO.puts()
+
+    IO.puts("===============")
+
+    Enum.each(alerts, &alert_to_output/1)
+
+    IO.puts("\n")
+  end
+
+  defp format_date(datetime) do
+    datetime |> Util.service_date() |> Timex.format!("%a %b %d", :strftime)
+  end
+
+  defp time_range(active_periods) do
+    periods = Enum.sort_by(active_periods, fn {start, _} -> start end)
+
+    {start, _} = List.first(periods)
+    {_, stop} = List.last(periods)
+
+    {start, stop}
+  end
+end
+```
+
+```elixir
+defmodule DotcomWeb.Components.PlannedDisruptions do
+  use Phoenix.Component
+
+  import MbtaMetro.Components.Accordion, only: [accordion: 1]
+
+  def disruptions(assigns) do
+    ~H"""
+    <div :for={{service_range, alerts} <- @disruptions}>
+      <h2><%= service_range_string(service_range) %></h2>
+      <.disruption :for={alert <- alerts} alert={alert} />
+    </div>
+    """
+  end
+
+  defp disruption(assigns) do
+    ~H"""
+    <.accordion >
+      <:heading>
+        <.heading alert={@alert} />
+      </:heading>
+      <:content>
+        <.content alert={@alert} />
+      </:content>
+    </.accordion>
+    """
+  end
+
+  defp heading(assigns) do
+    ~H"""
+    <% {start, stop} = alert_date_time_range(@alert) %>
+    <%= "[#{@alert.effect}] #{format_date(start)}-#{format_date(stop)}" %>
+    """
+  end
+
+  defp content(assigns) do
+    ~H"""
+
+    """
+  end
+
+  defp alert_date_time_range(%Alerts.Alert{active_period: active_period}) do
+    periods = Enum.sort_by(active_period, fn {start, _} -> start end)
+
+    {start, _} = List.first(periods)
+    {_, stop} = List.last(periods)
+
+    {start, stop}
+  end
+
+  defp format_date(datetime) do
+    datetime |> Util.service_date() |> Timex.format!("%a %b %d", :strftime)
+  end
+
+  defp service_range_string(service_range) do
+    service_range
+    |> Atom.to_string()
+    |> Recase.to_title()
+  end
+end
+
+alias DotcomWeb.Components.PlannedDisruptions
+
+assigns = %{
+  disruptions: Dotcom.Alerts.Disruptions.Subway.future_disruptions()
+}
+
+PlannedDisruptions.disruptions(assigns) |> KinoLiveComponent.component()
+```

test/dotcom/alerts/disruptions/subway_test.exs

@@ -0,0 +1,92 @@
+defmodule Dotcom.Alerts.Disruptions.SubwayTest do
+  use ExUnit.Case
+
+  import Dotcom.Alerts, only: [service_impacting_effects: 0]
+  import Dotcom.Alerts.Disruptions.Subway
+
+  import Dotcom.Utils.ServiceDateTime,
+    only: [
+      service_range_day: 0,
+      service_range_later_this_week: 0,
+      service_range_next_week: 0,
+      service_range_after_next_week: 0
+    ]
+
+  import Mox
+
+  alias Test.Support.Factories
+
+  setup :verify_on_exit!
+
+  setup _ do
+    stub_with(Dotcom.Utils.DateTime.Mock, Dotcom.Utils.DateTime)
+
+    :ok
+  end
+
+  describe "future_disruptions/0" do
+    test "returns an empty map when there are no alerts" do
+      expect(Alerts.Repo.Mock, :by_route_ids, fn _route_ids, _now ->
+        []
+      end)
+
+      # Exercise/Verify
+      assert %{} = future_disruptions()
+    end
+
+    test "returns alerts for later this week, next week, and after next week" do
+      # Setup
+      alert_today = service_range_day() |> disruption_alert()
+      alert_later_this_week = service_range_later_this_week() |> disruption_alert()
+      alert_next_week = service_range_next_week() |> disruption_alert()
+
+      {alert_after_next_week_start, _} = service_range_after_next_week()
+
+      alert_after_next_week =
+        {alert_after_next_week_start, Timex.shift(alert_after_next_week_start, days: 1)}
+        |> disruption_alert()
+
+      expect(Alerts.Repo.Mock, :by_route_ids, fn _route_ids, _now ->
+        [alert_today, alert_later_this_week, alert_next_week, alert_after_next_week]
+      end)
+
+      # Exercise/Verify
+      assert %{
+               later_this_week: [^alert_later_this_week],
+               next_week: [^alert_next_week],
+               after_next_week: [^alert_after_next_week]
+             } = future_disruptions()
+    end
+  end
+
+  describe "todays_disruptions/0" do
+    test "returns an empty map when there are no alerts" do
+      expect(Alerts.Repo.Mock, :by_route_ids, fn _route_ids, _now ->
+        []
+      end)
+
+      # Exercise/Verify
+      assert %{} = todays_disruptions()
+    end
+
+    test "returns alerts for today only" do
+      # Setup
+      alert_today = service_range_day() |> disruption_alert()
+      alert_next_week = service_range_next_week() |> disruption_alert()
+
+      expect(Alerts.Repo.Mock, :by_route_ids, fn _route_ids, _now ->
+        [alert_today, alert_next_week]
+      end)
+
+      # Exercise/Verify
+      assert %{today: [^alert_today]} = todays_disruptions()
+    end
+  end
+
+  defp disruption_alert(active_period) do
+    Factories.Alerts.Alert.build(:alert,
+      active_period: [active_period],
+      effect: service_impacting_effects() |> Faker.Util.pick()
+    )
+  end
+end