feat: make it possible to get all the mentors related to an event: went, didn't go

lib/bokken/accounts.ex

@@ -163,10 +163,33 @@ defmodule Bokken.Accounts do
     |> Map.fetch!(:mentors)
   end
 
+  alias Bokken.Events.Lecture
+
+  # List all mentors related to an event, including their attendance
   def list_mentors(%{"event_id" => event_id}) do
-    event_id
-    |> Events.get_event!([:mentors])
-    |> Map.fetch!(:mentors)
+    results =
+      Lecture
+      |> where([l], l.event_id == ^event_id)
+      |> join(:inner, [l], m in Mentor, on: m.id == l.mentor_id)
+      |> select([l, m], %{mentor: m, attendance: l.attendance})
+      |> Repo.all()
+
+    Enum.map(results, fn %{mentor: mentor, attendance: attendance} ->
+      Map.put(mentor, :attendance, attendance)
+    end)
+  end
+
+  def list_mentors(%{"event_id" => event_id}, attendances) when is_list(attendances) do
+    results =
+      Lecture
+      |> where([l], l.event_id == ^event_id and l.attendance in ^attendances)
+      |> join(:inner, [l], m in Mentor, on: m.id == l.mentor_id)
+      |> select([l, m], %{mentor: m, attendance: l.attendance})
+      |> Repo.all()
+
+    Enum.map(results, fn %{mentor: mentor, attendance: attendance} ->
+      Map.put(mentor, :attendance, attendance)
+    end)
   end
 
   def list_mentors do

lib/bokken/events.ex

@@ -840,4 +840,70 @@ defmodule Bokken.Events do
   def change_availability(%Availability{} = availability, attrs \\ %{}) do
     Availability.changeset(availability, attrs)
   end
+
+  @doc """
+  Lists all the users that can be notified about a new event.
+
+  ## Examples
+
+      iex> list_notifiable_signup_users()
+      [%User{}, ...]
+  """
+  def list_notifiable_signup_users do
+    Accounts.list_users()
+    |> Enum.filter(fn user ->
+      user.active and user.verified and user.role in [:guardian, :mentor]
+    end)
+  end
+
+  @doc """
+  Lists all the mentors that can be notified, because they have been selected for an event.
+
+  ## Examples
+
+      iex> list_notifiable_selected_mentors(%Event{})
+      [%Mentor{}, ...]
+  """
+  def list_notifiable_selected_mentors(%Event{} = event) do
+    Events.list_lectures(%{"event_id" => event.id}, [:mentor, :ninja, :event])
+    |> Enum.map(fn lecture ->
+      Accounts.get_user!(lecture.mentor.user_id) |> Map.put(:lecture, lecture)
+    end)
+  end
+
+  @doc """
+  Lists all the ninjas that can be notified, because they have been selected for an event.
+
+  ## Examples
+
+      iex> list_notifiable_selected_ninjas(%Event{})
+      [%Ninja{}, ...]
+  """
+  def list_notifiable_selected_ninjas(%Event{} = event) do
+    Events.list_lectures(%{"event_id" => event.id}, [:mentor, :ninja, :event])
+    |> Enum.map(fn lecture ->
+      Accounts.get_user!(lecture.ninja.guardian_id).user_id |> Map.put(:lecture, lecture)
+    end)
+  end
+
+  @doc """
+  Lists all the ninjas that won't be coming to an event.
+
+  ## Examples
+
+      iex> list_not_coming_ninjas(%Event{})
+      [%Ninja{}, ...]
+  """
+  def list_not_coming_ninjas(%Event{} = event) do
+    enrollments = list_enrollments(%{"event_id" => event.id})
+    lectures = list_lectures(%{"event_id" => event.id})
+
+    enrollments
+    |> Enum.filter(fn e ->
+      e.event_id == event.id and
+        not Enum.any?(lectures, fn l ->
+          l.ninja_id == e.ninja_id and l.event_id == e.event_id
+        end)
+    end)
+  end
 end

lib/bokken/events/lecture.ex

@@ -1,6 +1,6 @@
 defmodule Bokken.Events.Lecture do
   @moduledoc """
-  one on one lecture
+  Lecture between one or more mentors and a ninja.
   """
   use Bokken.Schema
 

lib/bokken_web/controllers/availability_controller.ex

@@ -1,26 +1,26 @@
 defmodule BokkenWeb.AvailabilityController do
-  use BokkenWeb, controller: "1.6"
+  use BokkenWeb, :controller
 
   alias Bokken.Events
   alias Bokken.Events.Availability
 
   action_fallback BokkenWeb.FallbackController
 
-  def show(conn, %{"id" => availability_id}) do
-    availability = Events.get_availability!(availability_id)
+  def index(conn, availability_params) do
+    availabilities = Events.list_availabilities(availability_params)
+    unavailabilities = Events.list_unavailabilities(availability_params, [:mentor])
 
     conn
     |> put_status(:ok)
-    |> render("show.json", availability: availability)
+    |> render(:index, availabilities: availabilities, unavailabilities: unavailabilities)
   end
 
-  def index(conn, availability_params) do
-    availabilities = Events.list_availabilities(availability_params, [:mentor])
-    unavailabilities = Events.list_unavailabilities(availability_params, [:mentor])
+  def show(conn, %{"id" => availability_id}) do
+    availability = Events.get_availability!(availability_id)
 
     conn
     |> put_status(:ok)
-    |> render("index.json", availabilities: availabilities, unavailabilities: unavailabilities)
+    |> render(:show, availability: availability)
   end
 
   def create(conn, %{
@@ -37,9 +37,9 @@ defmodule BokkenWeb.AvailabilityController do
       |> put_status(:created)
       |> put_resp_header(
         "location",
-        Routes.event_availability_path(conn, :show, event, availability)
+        ~p"/api/events/#{event}/availabilities/#{availability}"
       )
-      |> render("show.json", availability: availability)
+      |> render(:show, availability: availability)
     end
   end
 
@@ -50,7 +50,7 @@ defmodule BokkenWeb.AvailabilityController do
            Events.update_availability(old_availability, availability_params) do
       conn
       |> put_status(:ok)
-      |> render("show.json", availability: new_availability)
+      |> render(:show, availability: new_availability)
     end
   end
 end

lib/bokken_web/controllers/availability_json.ex

@@ -0,0 +1,48 @@
+defmodule BokkenWeb.AvailabilityJSON do
+  alias Bokken.Events.Availability
+
+  alias BokkenWeb.EventJSON
+  alias BokkenWeb.MentorJSON
+
+  def index(%{
+        availabilities: availabilities,
+        unavailabilities: unavailabilities,
+        current_user: current_user
+      }) do
+    %{
+      availabilities: for(availability <- availabilities, do: data(availability, current_user)),
+      unavailabilities:
+        for(availability <- unavailabilities, do: data(availability, current_user))
+    }
+  end
+
+  def show(%{availability: availability, current_user: current_user}) do
+    %{data: data(availability, current_user)}
+  end
+
+  def data(%Availability{} = availability, current_user) do
+    %{
+      availability_id: availability.id,
+      is_available: availability.is_available,
+      notes: availability.notes
+    }
+    |> Map.merge(event(availability))
+    |> Map.merge(mentor(availability, current_user))
+  end
+
+  defp event(availability) do
+    if Ecto.assoc_loaded?(availability.event) do
+      EventJSON.data(availability.event)
+    else
+      %{event_id: availability.event_id}
+    end
+  end
+
+  defp mentor(availability, current_user) do
+    if Ecto.assoc_loaded?(availability.mentor) do
+      MentorJSON.data(availability.mentor, current_user)
+    else
+      %{mentor_id: availability.mentor_id}
+    end
+  end
+end