Add Team Assessments

.credo.exs

@@ -94,7 +94,7 @@
         {Credo.Check.Readability.SpaceAfterCommas},
         {Credo.Check.Refactor.DoubleBooleanNegation},
         {Credo.Check.Refactor.CondStatements},
-        {Credo.Check.Refactor.CyclomaticComplexity},
+        {Credo.Check.Refactor.CyclomaticComplexity, max_complexity: 10},
         {Credo.Check.Refactor.FunctionArity},
         {Credo.Check.Refactor.LongQuoteBlocks},
         {Credo.Check.Refactor.MatchInCondition},

.iex.exs

@@ -1,5 +1,5 @@
 import Ecto.Query
 alias Cadet.Repo
-alias Cadet.Accounts.User
+alias Cadet.Accounts.{User, Team, TeamMember}
 alias Cadet.Assessments.{Answer, Assessment, Question, Submission}
 alias Cadet.Courses.Group

lib/cadet/accounts/notifications.ex

@@ -8,7 +8,7 @@ defmodule Cadet.Accounts.Notifications do
   import Ecto.Query
 
   alias Cadet.Repo
-  alias Cadet.Accounts.{Notification, CourseRegistration, CourseRegistration}
+  alias Cadet.Accounts.{Notification, CourseRegistration, CourseRegistration, Team, TeamMember}
   alias Cadet.Assessments.Submission
   alias Ecto.Multi
 
@@ -169,17 +169,47 @@ defmodule Cadet.Accounts.Notifications do
   @spec write_notification_when_graded(integer(), any()) ::
           {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
   def write_notification_when_graded(submission_id, type) when type in [:graded, :autograded] do
-    submission =
-      Submission
-      |> Repo.get_by(id: submission_id)
+    case Repo.get(Submission, submission_id) do
+      nil ->
+        {:error, %Ecto.Changeset{}}
 
-    write(%{
-      type: type,
-      read: false,
-      role: :student,
-      course_reg_id: submission.student_id,
-      assessment_id: submission.assessment_id
-    })
+      submission ->
+        case submission.student_id do
+          nil ->
+            team = Repo.get(Team, submission.team_id)
+
+            query =
+              from(t in Team,
+                join: tm in TeamMember,
+                on: t.id == tm.team_id,
+                join: cr in CourseRegistration,
+                on: tm.student_id == cr.id,
+                where: t.id == ^team.id,
+                select: cr.id
+              )
+
+            team_members = Repo.all(query)
+
+            Enum.each(team_members, fn tm_id ->
+              write(%{
+                type: type,
+                read: false,
+                role: :student,
+                course_reg_id: tm_id,
+                assessment_id: submission.assessment_id
+              })
+            end)
+
+          student_id ->
+            write(%{
+              type: type,
+              read: false,
+              role: :student,
+              course_reg_id: student_id,
+              assessment_id: submission.assessment_id
+            })
+        end
+    end
   end
 
   @doc """
@@ -223,7 +253,29 @@ defmodule Cadet.Accounts.Notifications do
   @spec write_notification_when_student_submits(Submission.t()) ::
           {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
   def write_notification_when_student_submits(submission = %Submission{}) do
-    avenger_id = get_avenger_id_of(submission.student_id)
+    id =
+      case submission.student_id do
+        nil ->
+          team_id = submission.team_id
+
+          team =
+            Repo.one(
+              from(t in Team,
+                where: t.id == ^team_id,
+                preload: [:team_members]
+              )
+            )
+
+          # Does not matter if team members have different Avengers
+          # Just require one of them to be notified of the submission
+          s_id = team.team_members |> hd() |> Map.get(:student_id)
+          s_id
+
+        _ ->
+          submission.student_id
+      end
+
+    avenger_id = get_avenger_id_of(id)
 
     if is_nil(avenger_id) do
       {:ok, nil}

lib/cadet/accounts/team.ex

@@ -0,0 +1,45 @@
+defmodule Cadet.Accounts.Team do
+  @moduledoc """
+  This module defines the Ecto schema and changeset for teams in the Cadet.Accounts context.
+  Teams represent groups of students collaborating on an assessment within a course.
+  """
+
+  use Cadet, :model
+
+  alias Cadet.Accounts.TeamMember
+  alias Cadet.Assessments.{Assessment, Submission}
+
+  @doc """
+  Ecto schema definition for teams.
+  This schema represents a group of students collaborating on a specific assessment within a course.
+  Fields:
+    - `assessment`: A reference to the assessment associated with the team.
+    - `submission`: A reference to the team's submission for the assessment.
+    - `team_members`: A list of team members associated with the team.
+  """
+  schema "teams" do
+    belongs_to(:assessment, Assessment)
+    has_one(:submission, Submission, on_delete: :delete_all)
+    has_many(:team_members, TeamMember, on_delete: :delete_all)
+
+    timestamps()
+  end
+
+  @required_fields ~w(assessment_id)a
+
+  @doc """
+  Builds an Ecto changeset for a team.
+  This function is used to create or update a team record based on the provided attributes.
+  Args:
+    - `team`: The existing team struct.
+    - `attrs`: The attributes to be cast and validated for the changeset.
+  Returns:
+    A changeset struct with cast and validated attributes.
+  """
+  def changeset(team, attrs) do
+    team
+    |> cast(attrs, @required_fields)
+    |> validate_required(@required_fields)
+    |> foreign_key_constraint(:assessment_id)
+  end
+end

lib/cadet/accounts/team_member.ex

@@ -0,0 +1,45 @@
+defmodule Cadet.Accounts.TeamMember do
+  @moduledoc """
+  This module defines the Ecto schema and changeset for team members in the Cadet.Accounts context.
+  Team members represent the association between a student and a team within a course.
+  """
+
+  use Ecto.Schema
+
+  import Ecto.Changeset
+
+  alias Cadet.Accounts.{CourseRegistration, Team}
+
+  @doc """
+  Ecto schema definition for team members.
+  This schema represents the relationship between a student and a team within a course.
+  Fields:
+    - `student`: A reference to the student's course registration.
+    - `team`: A reference to the team associated with the student.
+  """
+  schema "team_members" do
+    belongs_to(:student, CourseRegistration)
+    belongs_to(:team, Team)
+
+    timestamps()
+  end
+
+  @required_fields ~w(student_id team_id)a
+
+  @doc """
+  Builds an Ecto changeset for a team member.
+  This function is used to create or update a team member record based on the provided attributes.
+  Args:
+    - `team_member`: The existing team member struct.
+    - `attrs`: The attributes to be cast and validated for the changeset.
+  Returns:
+    A changeset struct with cast and validated attributes.
+  """
+  def changeset(team_member, attrs) do
+    team_member
+    |> cast(attrs, @required_fields)
+    |> validate_required(@required_fields)
+    |> foreign_key_constraint(:team_id)
+    |> foreign_key_constraint(:student_id)
+  end
+end