Merge pull request #185 from avantifellows/feat/render-session-with-s…

…ession-occurrences

Feat: Render session details with session occurrences

lib/dbservice/sessions.ex

@@ -132,102 +132,102 @@ defmodule Dbservice.Sessions do
     |> Repo.update()
   end
 
-  alias Dbservice.Sessions.SessionOccurence
+  alias Dbservice.Sessions.SessionOccurrence
 
   @doc """
-  Returns the list of session_occurence.
+  Returns the list of session_occurrence.
 
   ## Examples
 
-      iex> list_session_occurence()
-      [%SessionOccurence{}, ...]
+      iex> list_session_occurrence()
+      [%SessionOccurrence{}, ...]
 
   """
-  def list_session_occurence do
-    Repo.all(SessionOccurence)
+  def list_session_occurrence do
+    Repo.all(SessionOccurrence)
   end
 
   @doc """
-  Gets a single session_occurence.
+  Gets a single session_occurrence.
 
   Raises `Ecto.NoResultsError` if the Session occurence does not exist.
 
   ## Examples
 
-      iex> get_session_occurence!(123)
-      %SessionOccurence{}
+      iex> get_session_occurrence!(123)
+      %SessionOccurrence{}
 
-      iex> get_session_occurence!(456)
+      iex> get_session_occurrence!(456)
       ** (Ecto.NoResultsError)
 
   """
-  def get_session_occurence!(id) do
-    Repo.get!(SessionOccurence, id)
+  def get_session_occurrence!(id) do
+    Repo.get!(SessionOccurrence, id)
   end
 
   @doc """
-  Creates a session_occurence.
+  Creates a session_occurrence.
 
   ## Examples
 
-      iex> create_session_occurence(%{field: value})
-      {:ok, %SessionOccurence{}}
+      iex> create_session_occurrence(%{field: value})
+      {:ok, %SessionOccurrence{}}
 
-      iex> create_session_occurence(%{field: bad_value})
+      iex> create_session_occurrence(%{field: bad_value})
       {:error, %Ecto.Changeset{}}
 
   """
-  def create_session_occurence(attrs \\ %{}) do
-    %SessionOccurence{}
-    |> SessionOccurence.changeset(attrs)
+  def create_session_occurrence(attrs \\ %{}) do
+    %SessionOccurrence{}
+    |> SessionOccurrence.changeset(attrs)
     |> Repo.insert()
   end
 
   @doc """
-  Updates a session_occurence.
+  Updates a session_occurrence.
 
   ## Examples
 
-      iex> update_session_occurence(session_occurence, %{field: new_value})
-      {:ok, %SessionOccurence{}}
+      iex> update_session_occurrence(session_occurrence, %{field: new_value})
+      {:ok, %SessionOccurrence{}}
 
-      iex> update_session_occurence(session_occurence, %{field: bad_value})
+      iex> update_session_occurrence(session_occurrence, %{field: bad_value})
       {:error, %Ecto.Changeset{}}
 
   """
-  def update_session_occurence(%SessionOccurence{} = session_occurence, attrs) do
-    session_occurence
-    |> SessionOccurence.changeset(attrs)
+  def update_session_occurrence(%SessionOccurrence{} = session_occurrence, attrs) do
+    session_occurrence
+    |> SessionOccurrence.changeset(attrs)
     |> Repo.update()
   end
 
   @doc """
-  Deletes a session_occurence.
+  Deletes a session_occurrence.
 
   ## Examples
 
-      iex> delete_session_occurence(session_occurence)
-      {:ok, %SessionOccurence{}}
+      iex> delete_session_occurrence(session_occurrence)
+      {:ok, %SessionOccurrence{}}
 
-      iex> delete_session_occurence(session_occurence)
+      iex> delete_session_occurrence(session_occurrence)
       {:error, %Ecto.Changeset{}}
 
   """
-  def delete_session_occurence(%SessionOccurence{} = session_occurence) do
-    Repo.delete(session_occurence)
+  def delete_session_occurrence(%SessionOccurrence{} = session_occurrence) do
+    Repo.delete(session_occurrence)
   end
 
   @doc """
-  Returns an `%Ecto.Changeset{}` for tracking session_occurence changes.
+  Returns an `%Ecto.Changeset{}` for tracking session_occurrence changes.
 
   ## Examples
 
-      iex> change_session_occurence(session_occurence)
-      %Ecto.Changeset{data: %SessionOccurence{}}
+      iex> change_session_occurrence(session_occurrence)
+      %Ecto.Changeset{data: %SessionOccurrence{}}
 
   """
-  def change_session_occurence(%SessionOccurence{} = session_occurence, attrs \\ %{}) do
-    SessionOccurence.changeset(session_occurence, attrs)
+  def change_session_occurrence(%SessionOccurrence{} = session_occurrence, attrs \\ %{}) do
+    SessionOccurrence.changeset(session_occurrence, attrs)
   end
 
   alias Dbservice.Sessions.UserSession

lib/dbservice/sessions/session.ex

@@ -7,6 +7,7 @@ defmodule Dbservice.Sessions.Session do
   alias Dbservice.Users.User
   alias Dbservice.Groups.Group
   alias Dbservice.Sessions.SessionSchedule
+  alias Dbservice.Sessions.SessionOccurrence
 
   schema "session" do
     field(:end_time, :utc_datetime)
@@ -37,6 +38,7 @@ defmodule Dbservice.Sessions.Session do
     many_to_many(:users, User, join_through: "user_session", on_replace: :delete)
     many_to_many(:group, Group, join_through: "group_session", on_replace: :delete)
     has_many(:session_schedule, SessionSchedule)
+    has_many(:session_occurrence, SessionOccurrence)
   end
 
   @doc false

lib/dbservice/sessions/session_occurence.ex

@@ -1,4 +1,4 @@
-defmodule Dbservice.Sessions.SessionOccurence do
+defmodule Dbservice.Sessions.SessionOccurrence do
   @moduledoc false
 
   use Ecto.Schema
@@ -10,12 +10,12 @@ defmodule Dbservice.Sessions.SessionOccurence do
   schema "session_occurrence" do
     field :end_time, :utc_datetime
     field :start_time, :utc_datetime
-    field :session_fk, :id
     field :session_id, :string
 
     timestamps()
 
     many_to_many :users, User, join_through: "user_session", on_replace: :delete
+    belongs_to :session, Dbservice.Sessions.Session, foreign_key: :session_fk
   end
 
   @doc false

lib/dbservice/users/user.ex

@@ -5,7 +5,7 @@ defmodule Dbservice.Users.User do
   import Ecto.Changeset
   import Dbservice.Utils.Util
 
-  alias Dbservice.Sessions.SessionOccurence
+  alias Dbservice.Sessions.SessionOccurrence
   alias Dbservice.Users.Teacher
   alias Dbservice.Users.Student
   alias Dbservice.Profiles.UserProfile
@@ -31,7 +31,7 @@ defmodule Dbservice.Users.User do
 
     timestamps()
 
-    many_to_many(:sessions, SessionOccurence, join_through: "user_session", on_replace: :delete)
+    many_to_many(:sessions, SessionOccurrence, join_through: "user_session", on_replace: :delete)
     has_one(:teacher, Teacher)
     has_one(:student, Student)
     has_one(:user_profile, UserProfile)

lib/dbservice_web/controllers/session_occurence_controller.ex

@@ -1,16 +1,16 @@
-defmodule DbserviceWeb.SessionOccurenceController do
+defmodule DbserviceWeb.SessionOccurrenceController do
   use DbserviceWeb, :controller
 
   import Ecto.Query
   alias Dbservice.Repo
   alias Dbservice.Sessions
-  alias Dbservice.Sessions.SessionOccurence
+  alias Dbservice.Sessions.SessionOccurrence
 
   action_fallback(DbserviceWeb.FallbackController)
 
   use PhoenixSwagger
 
-  alias DbserviceWeb.SwaggerSchema.SessionOccurence, as: SwaggerSchemaSessionOccurrence
+  alias DbserviceWeb.SwaggerSchema.SessionOccurrence, as: SwaggerSchemaSessionOccurrence
 
   def swagger_definitions do
     # merge the required definitions in a pair at a time using the Map.merge/2 function
@@ -37,8 +37,14 @@ defmodule DbserviceWeb.SessionOccurenceController do
   end
 
   def index(conn, params) do
+    today = Date.utc_today()
+
+    # Construct the beginning and end of today
+    today_start = NaiveDateTime.new!(today, ~T[00:00:00])
+    today_end = NaiveDateTime.new!(today, ~T[23:59:59])
+
     query =
-      from(m in SessionOccurence,
+      from(m in SessionOccurrence,
         order_by: [asc: m.id],
         offset: ^params["offset"],
         limit: ^params["limit"]
@@ -47,14 +53,22 @@ defmodule DbserviceWeb.SessionOccurenceController do
     query =
       Enum.reduce(params, query, fn {key, value}, acc ->
         case String.to_existing_atom(key) do
-          :offset -> acc
-          :limit -> acc
-          atom -> from(u in acc, where: field(u, ^atom) == ^value)
+          :offset ->
+            acc
+
+          :limit ->
+            acc
+
+          :is_start_time when value == "today" ->
+            from(u in acc, where: u.start_time >= ^today_start and u.start_time <= ^today_end)
+
+          atom ->
+            from(u in acc, where: field(u, ^atom) == ^value)
         end
       end)
 
-    session_occurence = Repo.all(query)
-    render(conn, "index.json", session_occurence: session_occurence)
+    session_occurrence = Repo.all(query)
+    render(conn, "index.json", session_occurrence: session_occurrence)
   end
 
   swagger_path :create do
@@ -68,15 +82,15 @@ defmodule DbserviceWeb.SessionOccurenceController do
   end
 
   def create(conn, params) do
-    with {:ok, %SessionOccurence{} = session_occurence} <-
-           Sessions.create_session_occurence(params) do
+    with {:ok, %SessionOccurrence{} = session_occurrence} <-
+           Sessions.create_session_occurrence(params) do
       conn
       |> put_status(:created)
       |> put_resp_header(
         "location",
-        Routes.session_occurence_path(conn, :show, session_occurence)
+        Routes.session_occurrence_path(conn, :show, session_occurrence)
       )
-      |> render("show.json", session_occurence: session_occurence)
+      |> render("show.json", session_occurrence: session_occurrence)
     end
   end
 
@@ -93,8 +107,8 @@ defmodule DbserviceWeb.SessionOccurenceController do
   end
 
   def show(conn, %{"id" => id}) do
-    session_occurence = Sessions.get_session_occurence!(id)
-    render(conn, "show.json", session_occurence: session_occurence)
+    session_occurrence = Sessions.get_session_occurrence!(id)
+    render(conn, "show.json", session_occurrence: session_occurrence)
   end
 
   swagger_path :update do
@@ -109,11 +123,11 @@ defmodule DbserviceWeb.SessionOccurenceController do
   end
 
   def update(conn, params) do
-    session_occurence = Sessions.get_session_occurence!(params["id"])
+    session_occurrence = Sessions.get_session_occurrence!(params["id"])
 
-    with {:ok, %SessionOccurence{} = session_occurence} <-
-           Sessions.update_session_occurence(session_occurence, params) do
-      render(conn, "show.json", session_occurence: session_occurence)
+    with {:ok, %SessionOccurrence{} = session_occurrence} <-
+           Sessions.update_session_occurrence(session_occurrence, params) do
+      render(conn, "show.json", session_occurrence: session_occurrence)
     end
   end
 
@@ -130,9 +144,9 @@ defmodule DbserviceWeb.SessionOccurenceController do
   end
 
   def delete(conn, %{"id" => id}) do
-    session_occurence = Sessions.get_session_occurence!(id)
+    session_occurrence = Sessions.get_session_occurrence!(id)
 
-    with {:ok, %SessionOccurence{}} <- Sessions.delete_session_occurence(session_occurence) do
+    with {:ok, %SessionOccurrence{}} <- Sessions.delete_session_occurrence(session_occurrence) do
       send_resp(conn, :no_content, "")
     end
   end

lib/dbservice_web/router.ex

@@ -27,7 +27,7 @@ defmodule DbserviceWeb.Router do
     resources("/enrollment-record", EnrollmentRecordController, except: [:new, :edit])
     resources("/session", SessionController, only: [:index, :create, :update, :show])
     post("/session/:id/update-groups", SessionController, :update_groups)
-    resources("/session-occurrence", SessionOccurenceController, except: [:new, :edit])
+    resources("/session-occurrence", SessionOccurrenceController, except: [:new, :edit])
     resources("/user-session", UserSessionController, except: [:new, :edit])
     get("/group-session/session-auth-group", GroupSessionController, :get_auth_group_from_session)
     resources("/group-session", GroupSessionController, except: [:new, :edit])

lib/dbservice_web/swagger_schemas/session_occurence.ex

@@ -1,4 +1,4 @@
-defmodule DbserviceWeb.SwaggerSchema.SessionOccurence do
+defmodule DbserviceWeb.SwaggerSchema.SessionOccurrence do
   @moduledoc false
 
   use PhoenixSwagger

lib/dbservice_web/views/session_occurence_view.ex

@@ -1,39 +1,43 @@
-defmodule DbserviceWeb.SessionOccurenceView do
+defmodule DbserviceWeb.SessionOccurrenceView do
   use DbserviceWeb, :view
-  alias DbserviceWeb.SessionOccurenceView
+  alias DbserviceWeb.SessionOccurrenceView
   alias DbserviceWeb.UserView
+  alias DbserviceWeb.SessionView
   alias Dbservice.Repo
 
-  def render("index.json", %{session_occurence: session_occurence}) do
-    render_many(session_occurence, SessionOccurenceView, "session_occurence.json")
+  def render("index.json", %{session_occurrence: session_occurrence}) do
+    render_many(session_occurrence, SessionOccurrenceView, "session_occurrence.json")
   end
 
-  def render("show.json", %{session_occurence: session_occurence}) do
-    render_one(session_occurence, SessionOccurenceView, "session_occurence.json")
+  def render("show.json", %{session_occurrence: session_occurrence}) do
+    render_one(session_occurrence, SessionOccurrenceView, "session_occurrence.json")
   end
 
-  def render("session_occurence.json", %{session_occurence: session_occurence}) do
+  def render("session_occurrence.json", %{session_occurrence: session_occurrence}) do
+    session_occurrence = session_occurrence |> Repo.preload(:session)
+
     %{
-      id: session_occurence.id,
-      start_time: session_occurence.start_time,
-      end_time: session_occurence.end_time,
-      session_fk: session_occurence.session_fk,
-      session_id: session_occurence.session_id,
-      inserted_at: session_occurence.inserted_at,
-      updated_at: session_occurence.updated_at
+      id: session_occurrence.id,
+      start_time: session_occurrence.start_time,
+      end_time: session_occurrence.end_time,
+      session_fk: session_occurrence.session_fk,
+      session_id: session_occurrence.session_id,
+      inserted_at: session_occurrence.inserted_at,
+      updated_at: session_occurrence.updated_at,
+      session: render_one(session_occurrence.session, SessionView, "session.json")
     }
   end
 
-  def render("session_occurence_with_users.json", %{session_occurence: session_occurence}) do
-    session_occurence = session_occurence |> Repo.preload(:users)
+  def render("session_occurrence_with_users.json", %{session_occurrence: session_occurrence}) do
+    session_occurrence = session_occurrence |> Repo.preload(:users)
 
     %{
-      id: session_occurence.id,
-      start_time: session_occurence.start_time,
-      end_time: session_occurence.end_time,
-      session_fk: session_occurence.session_fk,
-      session_id: session_occurence.session_id,
-      users: render_many(session_occurence.users, UserView, "user.json")
+      id: session_occurrence.id,
+      start_time: session_occurrence.start_time,
+      end_time: session_occurrence.end_time,
+      session_fk: session_occurrence.session_fk,
+      session_id: session_occurrence.session_id,
+      users: render_many(session_occurrence.users, UserView, "user.json")
     }
   end
 end