feat: Disruption Diagram - Backend

lib/screens/alerts/alert.ex

@@ -572,6 +572,16 @@ defmodule Screens.Alerts.Alert do
     informed_entities
   end
 
+  @doc "Returns IDs of all subway routes affected by the alert. Green Line routes are not consolidated."
+  def informed_subway_routes(%__MODULE__{} = alert) do
+    informed_route_ids = MapSet.new(alert.informed_entities, & &1.route)
+
+    Enum.filter(
+      ["Blue", "Orange", "Red", "Green-B", "Green-C", "Green-D", "Green-E"],
+      &(&1 in informed_route_ids)
+    )
+  end
+
   def effect(%__MODULE__{effect: effect}), do: effect
 
   def direction_id(%__MODULE__{informed_entities: informed_entities}),

lib/screens/stops/stop.ex

@@ -15,6 +15,7 @@ defmodule Screens.Stops.Stop do
   alias Screens.RoutePatterns.RoutePattern
   alias Screens.Routes
   alias Screens.Routes.Route
+  alias Screens.RouteType
   alias Screens.Stops.StationsWithRoutesAgent
   alias Screens.Util
   alias Screens.V3Api
@@ -208,8 +209,6 @@ defmodule Screens.Stops.Stop do
   ]
 
   @green_line_trunk_stops [
-    # These 3 eventually will NOT be trunk stops, but are until Medford opens
-    {"place-unsqu", {"Union Square", "Union Sq"}},
     {"place-lech", {"Lechmere", "Lechmere"}},
     {"place-spmnl", {"Science Park/West End", "Science Pk"}},
     {"place-north", {"North Station", "North Sta"}},
@@ -223,6 +222,18 @@ defmodule Screens.Stops.Stop do
     {"place-kencl", {"Kenmore", "Kenmore"}}
   ]
 
+  @medford_tufts_branch_stops [
+    {"place-mdftf", {"Medford / Tufts", "Medford"}},
+    {"place-balsq", {"Ball Square", "Ball Sq"}},
+    {"place-mgngl", {"Magoun Square", "Magoun Sq"}},
+    {"place-gilmn", {"Gilman Square", "Gilman Sq"}},
+    {"place-esomr", {"East Somerville", "E Somerville"}}
+  ]
+
+  @union_square_branch_stops [
+    {"place-unsqu", {"Union Square", "Union Sq"}}
+  ]
+
   @route_stop_sequences %{
     "Blue" => [@blue_line_stops],
     "Orange" => [@orange_line_stops],
@@ -481,7 +492,7 @@ defmodule Screens.Stops.Stop do
 
   # Returns the route types we care about for the alerts of this screen type / place
   @spec get_route_type_filter(screen_type(), String.t()) ::
-          list(atom())
+          list(RouteType.t())
   def get_route_type_filter(app, _) when app in [BusEink, BusShelter], do: [:bus]
   def get_route_type_filter(GlEink, _), do: [:light_rail]
   # Ashmont should not show Mattapan alerts for PreFare or Dup
@@ -504,4 +515,75 @@ defmodule Screens.Stops.Stop do
     |> Enum.flat_map(fn stop_sequence -> Util.slice_after(stop_sequence, stop_id) end)
     |> MapSet.new()
   end
+
+  def on_glx?(stop_id) do
+    stop_id in Enum.map(@medford_tufts_branch_stops ++ @union_square_branch_stops, &elem(&1, 0))
+  end
+
+  @doc """
+  Only for use in building test data!
+  In production code, use `Screens.Routes.Route.fetch_routes_by_stop/1`
+  or `t:t.fetch_location_context/1`.
+
+  Returns IDs of the subway/light rail route(s) that serve the given station,
+  using our hardcoded stop sequences rather than API calls.
+  """
+  def __subway_routes_at_station(parent_station_id) do
+    @route_stop_sequences
+    |> Enum.filter(fn
+      # Green isn't a real route ID, ignore it.
+      {"Green", _} ->
+        false
+
+      {_route_id, labeled_sequences} ->
+        stop_sequences =
+          Enum.map(labeled_sequences, fn labeled_sequence ->
+            Enum.map(labeled_sequence, &elem(&1, 0))
+          end)
+
+        Enum.any?(stop_sequences, &(parent_station_id in &1))
+    end)
+    |> Enum.map(fn {route_id, _stop_sequences} -> route_id end)
+  end
+
+  @doc """
+  Only for use in building test data!
+
+  Returns a list of stop sequence(s) that contain the given subway/light rail station.
+  """
+  def __stop_sequences_through_station(parent_station_id) do
+    Enum.flat_map(@route_stop_sequences, fn
+      # Green isn't a real route ID, ignore it.
+      {"Green", _} ->
+        []
+
+      {_route_id, labeled_sequences} ->
+        Enum.flat_map(labeled_sequences, fn labeled_sequence ->
+          stop_sequence = Enum.map(labeled_sequence, &elem(&1, 0))
+          if parent_station_id in stop_sequence, do: [stop_sequence], else: []
+        end)
+    end)
+  end
+
+  @doc """
+  Only for use in building test data!
+  (Though maybe it could be useful elsewhere?)
+
+  Returns IDs of the route(s) whose stop sequence(s) contain all of the given stops.
+  """
+  def __routes_containing_all(parent_station_ids) do
+    @route_stop_sequences
+    |> Enum.filter(fn
+      # Green isn't a real route ID, ignore it.
+      {"Green", _} ->
+        false
+
+      {_route_id, labeled_sequences} ->
+        Enum.any?(labeled_sequences, fn labeled_sequence ->
+          stops = MapSet.new(labeled_sequence, &elem(&1, 0))
+          MapSet.subset?(parent_station_ids, stops)
+        end)
+    end)
+    |> Enum.map(fn {route_id, _} -> route_id end)
+  end
 end