18dc689a4df4836fc6967bf0f74dc252964bd175-PR-1180

Committed 08 Sep 2024 06:14PM UTC coverage: 79.088% (-15.3%) from 94.372%

Build # 18dc689a4df4836fc6967bf0f74dc252964bd175-PR-1180

Build Type

Pull #1180

github

Committed by

josh1248

Commit Message

Change appropriate routes into admin scope

Pull Request Pull Request #1180: Transfer groundControl (and admin panel) from staff to admin route

Run Details

7 of 12 new or added lines in 1 file covered. (58.33%)

499 existing lines in 25 files now uncovered.

2602 of 3290 relevant lines covered (79.09%)

1023.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/lib/cadet_web/admin_views/admin_grading_view.ex

defmodule CadetWeb.AdminGradingView do
  use CadetWeb, :view

  import CadetWeb.AssessmentsHelpers

  def render("show.json", %{answers: answers, assessment: assessment}) do
    %{
      assessment:
        render_one(assessment, CadetWeb.AdminGradingView, "assessment.json", as: :assessment),
      answers: render_many(answers, CadetWeb.AdminGradingView, "grading_info.json", as: :answer)
    }
  end

  def render("assessment.json", %{assessment: assessment}) do
    %{
      id: assessment.id,
      title: assessment.title,
      summaryShort: assessment.summary_short,
      summaryLong: assessment.summary_long,
      coverPicture: assessment.cover_picture,
      number: assessment.number,
      story: assessment.story,
      reading: assessment.reading
    }
  end

  def render("gradingsummaries.json", %{
        count: count,
        data: %{
          users: users,
          assessments: assessments,
          submissions: submissions,
          teams: teams,
          team_members: team_members
        }
      }) do
    %{
      count: count,
      data:
        for submission <- submissions do
          user = users |> Enum.find(&(&1.id == submission.student_id))
          assessment = assessments |> Enum.find(&(&1.id == submission.assessment_id))
          team = teams |> Enum.find(&(&1.id == submission.team_id))
          team_members = team_members |> Enum.filter(&(&1.team_id == submission.team_id))

          team_member_users =
            team_members
            |> Enum.map(fn team_member ->
              users |> Enum.find(&(&1.id == team_member.student_id))
            end)

          render(
            CadetWeb.AdminGradingView,
            "gradingsummary.json",
            %{
              user: user,
              assessment: assessment,
              submission: submission,
              team: team,
              team_members: team_member_users,
              unsubmitter:
                case submission.unsubmitted_by_id do
                  nil -> nil
                  _ -> users |> Enum.find(&(&1.id == submission.unsubmitted_by_id))
                end
            }
          )
        end
    }
  end

  def render("gradingsummary.json", %{
        user: user,
        assessment: a,
        submission: s,
        team: team,
        team_members: team_members,
        unsubmitter: unsubmitter
      }) do
    s
    |> transform_map_for_view(%{
      id: :id,
      status: :status,
      unsubmittedAt: :unsubmitted_at,
      xp: :xp,
      xpAdjustment: :xp_adjustment,
      xpBonus: :xp_bonus,
      isGradingPublished: :is_grading_published,
      gradedCount:
        &case &1.graded_count do
          nil -> 0
          x -> x
        end
    })
    |> Map.merge(%{
      assessment:
        render_one(a, CadetWeb.AdminGradingView, "gradingsummaryassessment.json", as: :assessment),
      student: render_one(user, CadetWeb.AdminGradingView, "gradingsummaryuser.json", as: :cr),
      team:
        render_one(team, CadetWeb.AdminGradingView, "gradingsummaryteam.json",
          as: :team,
          assigns: %{team_members: team_members}
        ),
      unsubmittedBy:
        case unsubmitter do
          nil -> nil
          cr -> transform_map_for_view(cr, %{id: :id, name: & &1.user.name})
        end
    })
  end

  def render("gradingsummaryassessment.json", %{assessment: a}) do
    %{
      id: a.id,
      title: a.title,
      assessmentNumber: a.number,
      isManuallyGraded: a.config.is_manually_graded,
      type: a.config.type,
      maxXp: a.questions |> Enum.map(& &1.max_xp) |> Enum.sum(),
      questionCount: a.questions |> Enum.count()
    }
  end

  def render("gradingsummaryteam.json", %{team: team, assigns: %{team_members: team_members}}) do
    %{
      id: team.id,
      team_members:
        render_many(team_members, CadetWeb.AdminGradingView, "gradingsummaryuser.json", as: :cr)
    }
  end

  def render("gradingsummaryuser.json", %{cr: cr}) do
    %{
      id: cr.id,
      name: cr.user.name,
      username: cr.user.username,
      groupName:
        case cr.group do
          nil -> nil
          _ -> cr.group.name
        end,
      groupLeaderId:
        case cr.group do
          nil -> nil
          _ -> cr.group.leader_id
        end
    }
  end

  def render("grading_info.json", %{answer: answer}) do
    transform_map_for_view(answer, %{
      student: &extract_student_data(&1.submission.student),
      team: &extract_team_data(&1.submission.team),
      question: &build_grading_question/1,
      solution: &(&1.question.question["solution"] || ""),
      grade: &build_grade/1
    })
  end

  def render("grading_summary.json", %{cols: cols, summary: summary}) do
    %{cols: cols, rows: summary}
  end

  defp extract_student_data(nil), do: %{}

  defp extract_student_data(student) do
    transform_map_for_view(student, %{
      name: fn st -> st.user.name end,
      id: :id,
      username: fn st -> st.user.username end
    })
  end

  defp extract_team_member_data(team_member) do
    transform_map_for_view(team_member, %{
      name: & &1.student.user.name,
      id: :id,
      username: & &1.student.user.username
    })
  end

  defp extract_team_data(nil), do: %{}

  defp extract_team_data(team) do
    members = team.team_members

    case members do
      [] -> nil
      _ -> Enum.map(members, &extract_team_member_data/1)
    end
  end

  defp build_grading_question(answer) do
    %{question: answer.question}
    |> build_question_by_question_config(true)
    |> Map.put(:answer, answer.answer["code"] || answer.answer["choice_id"])
    |> Map.put(:autogradingStatus, answer.autograding_status)
    |> Map.put(:autogradingResults, answer.autograding_results)
  end

  defp build_grade(answer = %{grader: grader}) do
    transform_map_for_view(answer, %{
      grader: grader_builder(grader),
      gradedAt: graded_at_builder(grader),
      xp: :xp,
      xpAdjustment: :xp_adjustment,
      comments: :comments
    })
  end
end

1	defmodule CadetWeb.AdminGradingView do
2	use CadetWeb, :view
3
4	import CadetWeb.AssessmentsHelpers
5
6	def render("show.json", %{answers: answers, assessment: assessment}) do
UNCOV 7	%{	×
8	assessment:
9	render_one(assessment, CadetWeb.AdminGradingView, "assessment.json", as: :assessment),
10	answers: render_many(answers, CadetWeb.AdminGradingView, "grading_info.json", as: :answer)
11	}
12	end
13
14	def render("assessment.json", %{assessment: assessment}) do
UNCOV 15	%{	×
UNCOV 16	id: assessment.id,	×
UNCOV 17	title: assessment.title,	×
UNCOV 18	summaryShort: assessment.summary_short,	×
UNCOV 19	summaryLong: assessment.summary_long,	×
UNCOV 20	coverPicture: assessment.cover_picture,	×
UNCOV 21	number: assessment.number,	×
UNCOV 22	story: assessment.story,	×
UNCOV 23	reading: assessment.reading	×
24	}
25	end
26
27	def render("gradingsummaries.json", %{
28	count: count,
29	data: %{
30	users: users,
31	assessments: assessments,
32	submissions: submissions,
33	teams: teams,
34	team_members: team_members
35	}
36	}) do
UNCOV 37	%{	×
38	count: count,
39	data:
UNCOV 40	for submission <- submissions do	×
UNCOV 41	user = users \|> Enum.find(&(&1.id == submission.student_id))	×
UNCOV 42	assessment = assessments \|> Enum.find(&(&1.id == submission.assessment_id))	×
UNCOV 43	team = teams \|> Enum.find(&(&1.id == submission.team_id))	×
UNCOV 44	team_members = team_members \|> Enum.filter(&(&1.team_id == submission.team_id))	×
45
UNCOV 46	team_member_users =	×
47	team_members
48	\|> Enum.map(fn team_member ->
49	users \|> Enum.find(&(&1.id == team_member.student_id))	×
50	end)
51
UNCOV 52	render(	×
53	CadetWeb.AdminGradingView,
54	"gradingsummary.json",
55	%{
56	user: user,
57	assessment: assessment,
58	submission: submission,
59	team: team,
60	team_members: team_member_users,
61	unsubmitter:
UNCOV 62	case submission.unsubmitted_by_id do	×
UNCOV 63	nil -> nil	×
64	_ -> users \|> Enum.find(&(&1.id == submission.unsubmitted_by_id))	×
65	end
66	}
67	)
68	end
69	}
70	end
71
72	def render("gradingsummary.json", %{
73	user: user,
74	assessment: a,
75	submission: s,
76	team: team,
77	team_members: team_members,
78	unsubmitter: unsubmitter
79	}) do
80	s
81	\|> transform_map_for_view(%{
82	id: :id,
83	status: :status,
84	unsubmittedAt: :unsubmitted_at,
85	xp: :xp,
86	xpAdjustment: :xp_adjustment,
87	xpBonus: :xp_bonus,
88	isGradingPublished: :is_grading_published,
89	gradedCount:
UNCOV 90	&case &1.graded_count do	×
91	nil -> 0	×
UNCOV 92	x -> x	×
93	end
94	})
UNCOV 95	\|> Map.merge(%{	×
96	assessment:
97	render_one(a, CadetWeb.AdminGradingView, "gradingsummaryassessment.json", as: :assessment),
98	student: render_one(user, CadetWeb.AdminGradingView, "gradingsummaryuser.json", as: :cr),
99	team:
100	render_one(team, CadetWeb.AdminGradingView, "gradingsummaryteam.json",
101	as: :team,
102	assigns: %{team_members: team_members}
103	),
104	unsubmittedBy:
105	case unsubmitter do
UNCOV 106	nil -> nil	×
107	cr -> transform_map_for_view(cr, %{id: :id, name: & &1.user.name})	×
108	end
109	})
110	end
111
112	def render("gradingsummaryassessment.json", %{assessment: a}) do
UNCOV 113	%{	×
UNCOV 114	id: a.id,	×
UNCOV 115	title: a.title,	×
UNCOV 116	assessmentNumber: a.number,	×
UNCOV 117	isManuallyGraded: a.config.is_manually_graded,	×
UNCOV 118	type: a.config.type,	×
UNCOV 119	maxXp: a.questions \|> Enum.map(& &1.max_xp) \|> Enum.sum(),	×
UNCOV 120	questionCount: a.questions \|> Enum.count()	×
121	}
122	end
123
124	def render("gradingsummaryteam.json", %{team: team, assigns: %{team_members: team_members}}) do
125	%{	×
126	id: team.id,	×
127	team_members:
128	render_many(team_members, CadetWeb.AdminGradingView, "gradingsummaryuser.json", as: :cr)
129	}
130	end
131
132	def render("gradingsummaryuser.json", %{cr: cr}) do
UNCOV 133	%{	×
UNCOV 134	id: cr.id,	×
UNCOV 135	name: cr.user.name,	×
UNCOV 136	username: cr.user.username,	×
137	groupName:
UNCOV 138	case cr.group do	×
139	nil -> nil	×
UNCOV 140	_ -> cr.group.name	×
141	end,
142	groupLeaderId:
UNCOV 143	case cr.group do	×
144	nil -> nil	×
UNCOV 145	_ -> cr.group.leader_id	×
146	end
147	}
148	end
149
150	def render("grading_info.json", %{answer: answer}) do
UNCOV 151	transform_map_for_view(answer, %{	×
UNCOV 152	student: &extract_student_data(&1.submission.student),	×
UNCOV 153	team: &extract_team_data(&1.submission.team),	×
154	question: &build_grading_question/1,
UNCOV 155	solution: &(&1.question.question["solution"] \|\| ""),	×
156	grade: &build_grade/1
157	})
158	end
159
160	def render("grading_summary.json", %{cols: cols, summary: summary}) do
UNCOV 161	%{cols: cols, rows: summary}	×
162	end
163
164	defp extract_student_data(nil), do: %{}	×
165
166	defp extract_student_data(student) do
UNCOV 167	transform_map_for_view(student, %{	×
UNCOV 168	name: fn st -> st.user.name end,	×
169	id: :id,
UNCOV 170	username: fn st -> st.user.username end	×
171	})
172	end
173
174	defp extract_team_member_data(team_member) do
175	transform_map_for_view(team_member, %{	×
176	name: & &1.student.user.name,	×
177	id: :id,
178	username: & &1.student.user.username	×
179	})
180	end
181
UNCOV 182	defp extract_team_data(nil), do: %{}	×
183
184	defp extract_team_data(team) do
185	members = team.team_members	×
186
187	case members do	×
188	[] -> nil	×
189	_ -> Enum.map(members, &extract_team_member_data/1)	×
190	end
191	end
192
193	defp build_grading_question(answer) do
UNCOV 194	%{question: answer.question}	×
195	\|> build_question_by_question_config(true)
UNCOV 196	\|> Map.put(:answer, answer.answer["code"] \|\| answer.answer["choice_id"])	×
UNCOV 197	\|> Map.put(:autogradingStatus, answer.autograding_status)	×
UNCOV 198	\|> Map.put(:autogradingResults, answer.autograding_results)	×
199	end
200
201	defp build_grade(answer = %{grader: grader}) do
UNCOV 202	transform_map_for_view(answer, %{	×
203	grader: grader_builder(grader),
204	gradedAt: graded_at_builder(grader),
205	xp: :xp,
206	xpAdjustment: :xp_adjustment,
207	comments: :comments
208	})
209	end
210	end

source-academy / backend / 18dc689a4df4836fc6967bf0f74dc252964bd175-PR-1180

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous