410d0308186c400f57ab0fc2b05beda552c8fdd2-PR-1180

defmodule CadetWeb.AdminGradingController do
  use CadetWeb, :controller
  use PhoenixSwagger

  alias Cadet.Assessments

  @doc """
  # Query Parameters
  - `pageSize`: Integer. The number of submissions to return. Default 10.
  - `offset`: Integer. The number of submissions to skip. Default 0.
  - `title`: String. Assessment title.
  - `status`: String. Submission status.
  - `isFullyGraded`: Boolean. Whether the submission is fully graded.
  - `isGradingPublished`: Boolean. Whether the grading is published.
  - `group`: Boolean. Only the groups under the grader should be returned.
  - `groupName`: String. Group name.
  - `name`: String. User name.
  - `username`: String. User username.
  - `type`: String. Assessment Config type.
  - `isManuallyGraded`: Boolean. Whether the assessment is manually graded.
  """
  def index(conn, %{"group" => group} = params)
      when group in ["true", "false"] do
    course_reg = conn.assigns[:course_reg]

    boolean_params = [:is_fully_graded, :group, :is_manually_graded]
    int_params = [:page_size, :offset]

    # Convert string keys to atoms and parse values
    params =
      params
      |> to_snake_case_atom_keys()
      |> Map.put_new(:page_size, "10")
      |> Map.put_new(:offset, "0")

    filtered_boolean_params =
      params
      |> Map.take(boolean_params)
      |> Map.keys()

    params =
      params
      |> process_map_booleans(filtered_boolean_params)
      |> process_map_integers(int_params)
      |> Assessments.parse_sort_direction()
      |> Assessments.parse_sort_by()

    case Assessments.submissions_by_grader_for_index(course_reg, params) do
      {:ok, view_model} ->
        conn
        |> put_status(:ok)
        |> put_resp_content_type("application/json")
        |> render("gradingsummaries.json", view_model)
    end
  end

  def index(conn, _) do
    index(conn, %{"group" => "false"})
  end

  def show(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
    case Assessments.get_answers_in_submission(submission_id) do
      {:ok, {answers, assessment}} ->
        render(conn, "show.json", answers: answers, assessment: assessment)

      {:error, {status, message}} ->
        conn
        |> put_status(status)
        |> text(message)
    end
  end

  def update(
        conn,
        %{
          "submissionid" => submission_id,
          "questionid" => question_id,
          "grading" => raw_grading
        }
      )
      when is_ecto_id(submission_id) and is_ecto_id(question_id) do
    course_reg = conn.assigns[:course_reg]

    grading = raw_grading |> snake_casify_string_keys()

    case Assessments.update_grading_info(
           %{submission_id: submission_id, question_id: question_id},
           grading,
           course_reg
         ) do
      {:ok, _} ->
        text(conn, "OK")

      {:error, {status, message}} ->
        conn
        |> put_status(status)
        |> text(message)
    end
  end

  def update(conn, _params) do
    conn
    |> put_status(:bad_request)
    |> text("Missing parameter")
  end

  def unsubmit(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
    course_reg = conn.assigns[:course_reg]

    case Assessments.unsubmit_submission(submission_id, course_reg) do
      {:ok, nil} ->
        text(conn, "OK")

      {:error, {status, message}} ->
        conn
        |> put_status(status)
        |> text(message)
    end
  end

  def unpublish_grades(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
    course_reg = conn.assigns[:course_reg]

    case Assessments.unpublish_grading(submission_id, course_reg) do
      {:ok, nil} ->
        text(conn, "OK")

      {:error, {status, message}} ->
        conn
        |> put_status(status)
        |> text(message)
    end
  end

  def publish_grades(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
    course_reg = conn.assigns[:course_reg]

    case Assessments.publish_grading(submission_id, course_reg) do
      {:ok, nil} ->
        text(conn, "OK")

      {:error, {status, message}} ->
        conn
        |> put_status(status)
        |> text(message)
    end
  end

  def publish_all_grades(conn, %{"assessmentid" => assessment_id})
      when is_ecto_id(assessment_id) do
    course_reg = conn.assigns[:course_reg]

    case Assessments.publish_all_graded(course_reg, assessment_id) do
      {:ok, nil} ->
        text(conn, "OK")

      {:error, {status, message}} ->
        conn
        |> put_status(status)
        |> text(message)
    end
  end

  def unpublish_all_grades(conn, %{"assessmentid" => assessment_id})
      when is_ecto_id(assessment_id) do
    course_reg = conn.assigns[:course_reg]

    case Assessments.unpublish_all(course_reg, assessment_id) do
      {:ok, nil} ->
        text(conn, "OK")

      {:error, {status, message}} ->
        conn
        |> put_status(status)
        |> text(message)
    end
  end

  def autograde_submission(conn, %{"submissionid" => submission_id}) do
    course_reg = conn.assigns[:course_reg]

    case Assessments.force_regrade_submission(submission_id, course_reg) do
      {:ok, nil} ->
        send_resp(conn, :no_content, "")

      {:error, {status, message}} ->
        conn
        |> put_status(status)
        |> text(message)
    end
  end

  def autograde_answer(conn, %{"submissionid" => submission_id, "questionid" => question_id}) do
    course_reg = conn.assigns[:course_reg]

    case Assessments.force_regrade_answer(submission_id, question_id, course_reg) do
      {:ok, nil} ->
        send_resp(conn, :no_content, "")

      {:error, {status, message}} ->
        conn
        |> put_status(status)
        |> text(message)
    end
  end

  def grading_summary(conn, %{"course_id" => course_id}) do
    case Assessments.get_group_grading_summary(course_id) do
      {:ok, cols, summary} ->
        render(conn, "grading_summary.json", cols: cols, summary: summary)
    end
  end

  swagger_path :index do
    get("/courses/{course_id}/admin/grading")

    summary("Get a list of all submissions with current user as the grader")

    security([%{JWT: []}])

    produces("application/json")

    parameters do
      group(
        :query,
        :boolean,
        "Show only students in the grader's group when true",
        required: false
      )
    end

    response(200, "OK", Schema.ref(:Submissions))
    response(401, "Unauthorised")
    response(403, "Forbidden")
  end

  swagger_path :unsubmit do
    post("/courses/{course_id}/admin/grading/{submissionId}/unsubmit")
    summary("Unsubmit submission. Can only be done by the Avenger of a student")
    security([%{JWT: []}])

    parameters do
      submissionId(:path, :integer, "submission id", required: true)
    end

    response(200, "OK")
    response(400, "Invalid parameters")
    response(403, "Forbidden")
    response(404, "Submission not found")
  end

  swagger_path :autograde_submission do
    post("/courses/{course_id}/admin/grading/{submissionId}/autograde")
    summary("Force re-autograding of an entire submission")
    security([%{JWT: []}])

    parameters do
      submissionId(:path, :integer, "submission id", required: true)
    end

    response(204, "Successful request")
    response(400, "Invalid parameters or submission not submitted")
    response(403, "Forbidden")
    response(404, "Submission not found")
  end

  swagger_path :autograde_answer do
    post("/courses/{course_id}/admin/grading/{submissionId}/{questionId}/autograde")
    summary("Force re-autograding of a question in a submission")
    security([%{JWT: []}])

    parameters do
      submissionId(:path, :integer, "submission id", required: true)
      questionId(:path, :integer, "question id", required: true)
    end

    response(204, "Successful request")
    response(400, "Invalid parameters or submission not submitted")
    response(403, "Forbidden")
    response(404, "Answer not found")
  end

  swagger_path :show do
    get("/courses/{course_id}/admin/grading/{submissionId}")

    summary("Get information about a specific submission to be graded")

    security([%{JWT: []}])

    produces("application/json")

    parameters do
      submissionId(:path, :integer, "submission id", required: true)
    end

    response(200, "OK", Schema.ref(:GradingInfo))
    response(400, "Invalid or missing parameter(s) or submission and/or question not found")
    response(401, "Unauthorised")
    response(403, "Forbidden")
  end

  swagger_path :update do
    post("/courses/{course_id}/admin/grading/{submissionId}/{questionId}")

    summary("Update marks given to the answer of a particular question in a submission")

    security([%{JWT: []}])

    consumes("application/json")
    produces("application/json")

    parameters do
      submissionId(:path, :integer, "submission id", required: true)
      questionId(:path, :integer, "question id", required: true)
      grading(:body, Schema.ref(:Grading), "adjustments for a question", required: true)
    end

    response(200, "OK")
    response(400, "Invalid or missing parameter(s) or submission and/or question not found")
    response(401, "Unauthorised")
    response(403, "Forbidden")
  end

  swagger_path :grading_summary do
    get("/courses/{course_id}/admin/grading/summary")

    summary("Receives a summary of grading items done by this grader")

    security([%{JWT: []}])

    produces("application/json")

    response(200, "OK", Schema.array(:GradingSummary))
    response(400, "Invalid or missing parameter(s) or submission and/or question not found")
    response(401, "Unauthorised")
    response(403, "Forbidden")
  end

  def swagger_definitions do
    %{
      Submissions:
        swagger_schema do
          type(:array)
          items(Schema.ref(:Submission))
        end,
      Submission:
        swagger_schema do
          properties do
            id(:integer, "Submission id", required: true)
            grade(:integer, "Grade given", required: true)
            xp(:integer, "XP earned", required: true)
            xpBonus(:integer, "Bonus XP for a given submission", required: true)
            xpAdjustment(:integer, "XP adjustment given", required: true)
            adjustment(:integer, "Grade adjustment given", required: true)

            status(
              Schema.ref(:AssessmentStatus),
              "One of 'not_attempted/attempting/attempted/submitted' indicating whether the assessment has been attempted by the current user",
              required: true
            )

            gradedCount(:integer, "Number of questions in this submission that have been graded",
              required: true
            )

            assessment(Schema.ref(:AssessmentInfo), "Assessment for which the submission is for",
              required: true
            )

            student(
              Schema.ref(:StudentInfo),
              "Student who created the submission",
              required: true
            )

            unsubmittedBy(Schema.ref(:GraderInfo))
            unsubmittedAt(:string, "Last unsubmitted at", format: "date-time", required: false)

            isGradingPublished(:boolean, "Whether the grading is published", required: true)
          end
        end,
      AssessmentInfo:
        swagger_schema do
          properties do
            id(:integer, "assessment id", required: true)

            config(Schema.ref(:AssessmentConfig), "Either mission/sidequest/path/contest",
              required: true
            )

            title(:string, "Mission title", required: true)

            maxGrade(
              :integer,
              "The max grade for this assessment",
              required: true
            )

            maxXp(
              :integer,
              "The max xp for this assessment",
              required: true
            )

            questionCount(:integer, "number of questions in this assessment", required: true)
          end
        end,
      StudentInfo:
        swagger_schema do
          properties do
            id(:integer, "student id", required: true)
            name(:string, "student name", required: true)
            username(:string, "student username", required: true)
            groupName(:string, "name of student's group")
            groupLeaderId(:integer, "user id of group leader")
          end
        end,
      GraderInfo:
        swagger_schema do
          properties do
            id(:integer, "grader id", required: true)
            name(:string, "grader name", required: true)
          end
        end,
      GradingInfo:
        swagger_schema do
          description(
            "A list of questions with submitted answers, solution and previous grading info " <>
              "if available"
          )

          type(:array)

          items(
            Schema.new do
              properties do
                question(Schema.ref(:Question), "Question", required: true)
                grade(Schema.ref(:Grade), "Grading information", required: true)
                student(Schema.ref(:StudentInfo), "Student", required: true)

                solution(
                  :string,
                  "the marking scheme and model solution to this question. Only available for programming questions",
                  required: true
                )

                maxGrade(
                  :integer,
                  "the max grade that can be given to this question",
                  required: true
                )

                maxXp(
                  :integer,
                  "the max xp that can be given to this question",
                  required: true
                )
              end
            end
          )
        end,
      GradingSummary:
        swagger_schema do
          description("Summary of grading items for current user as the grader")

          properties do
            groupName(:string, "Name of group this grader is in", required: true)
            leaderName(:string, "Name of group leader", required: true)
            submittedMissions(:integer, "Number of submitted missions", required: true)
            submittedSidequests(:integer, "Number of submitted sidequests", required: true)
            ungradedMissions(:integer, "Number of ungraded missions", required: true)
            ungradedSidequests(:integer, "Number of ungraded sidequests", required: true)
          end
        end,
      Grade:
        swagger_schema do
          properties do
            grade(:integer, "Grade awarded by autograder")
            xp(:integer, "XP awarded by autograder")
            adjustment(:integer, "Grade adjustment given")
            xpAdjustment(:integer, "XP adjustment given", required: true)
            grader(Schema.ref(:GraderInfo))
            gradedAt(:string, "Last graded at", format: "date-time", required: false)
            comments(:string, "Comments given by grader")
          end
        end,
      Grading:
        swagger_schema do
          properties do
            grading(
              Schema.new do
                properties do
                  adjustment(:integer, "Grade adjustment given")
                  xpAdjustment(:integer, "XP adjustment given")
                  comments(:string, "Comments given by grader")
                end
              end
            )
          end
        end
    }
  end
end

1	defmodule CadetWeb.AdminGradingController do
2	use CadetWeb, :controller
3	use PhoenixSwagger
4
5	alias Cadet.Assessments
6
7	@doc """
8	# Query Parameters
9	- `pageSize`: Integer. The number of submissions to return. Default 10.
10	- `offset`: Integer. The number of submissions to skip. Default 0.
11	- `title`: String. Assessment title.
12	- `status`: String. Submission status.
13	- `isFullyGraded`: Boolean. Whether the submission is fully graded.
14	- `isGradingPublished`: Boolean. Whether the grading is published.
15	- `group`: Boolean. Only the groups under the grader should be returned.
16	- `groupName`: String. Group name.
17	- `name`: String. User name.
18	- `username`: String. User username.
19	- `type`: String. Assessment Config type.
20	- `isManuallyGraded`: Boolean. Whether the assessment is manually graded.
21	"""
22	def index(conn, %{"group" => group} = params)
23	when group in ["true", "false"] do
24	course_reg = conn.assigns[:course_reg]	5✔
25
26	boolean_params = [:is_fully_graded, :group, :is_manually_graded]	5✔
27	int_params = [:page_size, :offset]	5✔
28
29	# Convert string keys to atoms and parse values
30	params =	5✔
31	params
32	\|> to_snake_case_atom_keys()
33	\|> Map.put_new(:page_size, "10")
34	\|> Map.put_new(:offset, "0")
35
36	filtered_boolean_params =	5✔
37	params
38	\|> Map.take(boolean_params)
39	\|> Map.keys()
40
41	params =	5✔
42	params
43	\|> process_map_booleans(filtered_boolean_params)
44	\|> process_map_integers(int_params)
45	\|> Assessments.parse_sort_direction()
46	\|> Assessments.parse_sort_by()
47
48	case Assessments.submissions_by_grader_for_index(course_reg, params) do	5✔
49	{:ok, view_model} ->
50	conn
51	\|> put_status(:ok)
52	\|> put_resp_content_type("application/json")
53	\|> render("gradingsummaries.json", view_model)	5✔
54	end
55	end
56
57	def index(conn, _) do
58	index(conn, %{"group" => "false"})	2✔
59	end
60
61	def show(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
62	case Assessments.get_answers_in_submission(submission_id) do	4✔
63	{:ok, {answers, assessment}} ->
64	render(conn, "show.json", answers: answers, assessment: assessment)	2✔
65
66	{:error, {status, message}} ->
67	conn
68	\|> put_status(status)
69	\|> text(message)	2✔
70	end
71	end
72
73	def update(
74	conn,
75	%{
76	"submissionid" => submission_id,
77	"questionid" => question_id,
78	"grading" => raw_grading
79	}
80	)
81	when is_ecto_id(submission_id) and is_ecto_id(question_id) do
82	course_reg = conn.assigns[:course_reg]	4✔
83
84	grading = raw_grading \|> snake_casify_string_keys()	4✔
85
86	case Assessments.update_grading_info(	4✔
87	%{submission_id: submission_id, question_id: question_id},
88	grading,
89	course_reg
90	) do
91	{:ok, _} ->
92	text(conn, "OK")	2✔
93
94	{:error, {status, message}} ->
95	conn
96	\|> put_status(status)
97	\|> text(message)	2✔
98	end
99	end
100
101	def update(conn, _params) do
102	conn
103	\|> put_status(:bad_request)
104	\|> text("Missing parameter")	2✔
105	end
106
107	def unsubmit(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
108	course_reg = conn.assigns[:course_reg]	8✔
109
110	case Assessments.unsubmit_submission(submission_id, course_reg) do	8✔
111	{:ok, nil} ->
112	text(conn, "OK")	4✔
113
114	{:error, {status, message}} ->
115	conn
116	\|> put_status(status)
117	\|> text(message)	4✔
118	end
119	end
120
121	def unpublish_grades(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
122	course_reg = conn.assigns[:course_reg]	3✔
123
124	case Assessments.unpublish_grading(submission_id, course_reg) do	3✔
125	{:ok, nil} ->
126	text(conn, "OK")	2✔
127
128	{:error, {status, message}} ->
129	conn
130	\|> put_status(status)
131	\|> text(message)	1✔
132	end
133	end
134
135	def publish_grades(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
136	course_reg = conn.assigns[:course_reg]	4✔
137
138	case Assessments.publish_grading(submission_id, course_reg) do	4✔
139	{:ok, nil} ->
140	text(conn, "OK")	2✔
141
142	{:error, {status, message}} ->
143	conn
144	\|> put_status(status)
145	\|> text(message)	2✔
146	end
147	end
148
149	def publish_all_grades(conn, %{"assessmentid" => assessment_id})
150	when is_ecto_id(assessment_id) do
151	course_reg = conn.assigns[:course_reg]	1✔
152
153	case Assessments.publish_all_graded(course_reg, assessment_id) do	1✔
154	{:ok, nil} ->
155	text(conn, "OK")	1✔
156
157	{:error, {status, message}} ->
158	conn
159	\|> put_status(status)
UNCOV 160	\|> text(message)	×
161	end
162	end
163
164	def unpublish_all_grades(conn, %{"assessmentid" => assessment_id})
165	when is_ecto_id(assessment_id) do
166	course_reg = conn.assigns[:course_reg]	1✔
167
168	case Assessments.unpublish_all(course_reg, assessment_id) do	1✔
169	{:ok, nil} ->
170	text(conn, "OK")	1✔
171
172	{:error, {status, message}} ->
173	conn
174	\|> put_status(status)
UNCOV 175	\|> text(message)	×
176	end
177	end
178
179	def autograde_submission(conn, %{"submissionid" => submission_id}) do
180	course_reg = conn.assigns[:course_reg]	2✔
181
182	case Assessments.force_regrade_submission(submission_id, course_reg) do	2✔
183	{:ok, nil} ->
184	send_resp(conn, :no_content, "")	1✔
185
186	{:error, {status, message}} ->
187	conn
188	\|> put_status(status)
189	\|> text(message)	1✔
190	end
191	end
192
193	def autograde_answer(conn, %{"submissionid" => submission_id, "questionid" => question_id}) do
194	course_reg = conn.assigns[:course_reg]	2✔
195
196	case Assessments.force_regrade_answer(submission_id, question_id, course_reg) do	2✔
197	{:ok, nil} ->
198	send_resp(conn, :no_content, "")	1✔
199
200	{:error, {status, message}} ->
201	conn
202	\|> put_status(status)
203	\|> text(message)	1✔
204	end
205	end
206
207	def grading_summary(conn, %{"course_id" => course_id}) do
208	case Assessments.get_group_grading_summary(course_id) do	1✔
209	{:ok, cols, summary} ->
210	render(conn, "grading_summary.json", cols: cols, summary: summary)	1✔
211	end
212	end
213
214	swagger_path :index do	1✔
215	get("/courses/{course_id}/admin/grading")
216
217	summary("Get a list of all submissions with current user as the grader")
218
219	security([%{JWT: []}])
220
221	produces("application/json")
222
223	parameters do
224	group(
225	:query,
226	:boolean,
227	"Show only students in the grader's group when true",
228	required: false
229	)
230	end
231
232	response(200, "OK", Schema.ref(:Submissions))
233	response(401, "Unauthorised")
234	response(403, "Forbidden")
235	end
236
237	swagger_path :unsubmit do	1✔
238	post("/courses/{course_id}/admin/grading/{submissionId}/unsubmit")
239	summary("Unsubmit submission. Can only be done by the Avenger of a student")
240	security([%{JWT: []}])
241
242	parameters do
243	submissionId(:path, :integer, "submission id", required: true)
244	end
245
246	response(200, "OK")
247	response(400, "Invalid parameters")
248	response(403, "Forbidden")
249	response(404, "Submission not found")
250	end
251
252	swagger_path :autograde_submission do	1✔
253	post("/courses/{course_id}/admin/grading/{submissionId}/autograde")
254	summary("Force re-autograding of an entire submission")
255	security([%{JWT: []}])
256
257	parameters do
258	submissionId(:path, :integer, "submission id", required: true)
259	end
260
261	response(204, "Successful request")
262	response(400, "Invalid parameters or submission not submitted")
263	response(403, "Forbidden")
264	response(404, "Submission not found")
265	end
266
267	swagger_path :autograde_answer do	1✔
268	post("/courses/{course_id}/admin/grading/{submissionId}/{questionId}/autograde")
269	summary("Force re-autograding of a question in a submission")
270	security([%{JWT: []}])
271
272	parameters do
273	submissionId(:path, :integer, "submission id", required: true)
274	questionId(:path, :integer, "question id", required: true)
275	end
276
277	response(204, "Successful request")
278	response(400, "Invalid parameters or submission not submitted")
279	response(403, "Forbidden")
280	response(404, "Answer not found")
281	end
282
283	swagger_path :show do	1✔
284	get("/courses/{course_id}/admin/grading/{submissionId}")
285
286	summary("Get information about a specific submission to be graded")
287
288	security([%{JWT: []}])
289
290	produces("application/json")
291
292	parameters do
293	submissionId(:path, :integer, "submission id", required: true)
294	end
295
296	response(200, "OK", Schema.ref(:GradingInfo))
297	response(400, "Invalid or missing parameter(s) or submission and/or question not found")
298	response(401, "Unauthorised")
299	response(403, "Forbidden")
300	end
301
302	swagger_path :update do	1✔
303	post("/courses/{course_id}/admin/grading/{submissionId}/{questionId}")
304
305	summary("Update marks given to the answer of a particular question in a submission")
306
307	security([%{JWT: []}])
308
309	consumes("application/json")
310	produces("application/json")
311
312	parameters do
313	submissionId(:path, :integer, "submission id", required: true)
314	questionId(:path, :integer, "question id", required: true)
315	grading(:body, Schema.ref(:Grading), "adjustments for a question", required: true)
316	end
317
318	response(200, "OK")
319	response(400, "Invalid or missing parameter(s) or submission and/or question not found")
320	response(401, "Unauthorised")
321	response(403, "Forbidden")
322	end
323
324	swagger_path :grading_summary do	1✔
325	get("/courses/{course_id}/admin/grading/summary")
326
327	summary("Receives a summary of grading items done by this grader")
328
329	security([%{JWT: []}])
330
331	produces("application/json")
332
333	response(200, "OK", Schema.array(:GradingSummary))
334	response(400, "Invalid or missing parameter(s) or submission and/or question not found")
335	response(401, "Unauthorised")
336	response(403, "Forbidden")
337	end
338
339	def swagger_definitions do
340	%{	1✔
341	Submissions:
342	swagger_schema do	1✔
343	type(:array)
344	items(Schema.ref(:Submission))
345	end,
346	Submission:
347	swagger_schema do	1✔
348	properties do	1✔
349	id(:integer, "Submission id", required: true)
350	grade(:integer, "Grade given", required: true)
351	xp(:integer, "XP earned", required: true)
352	xpBonus(:integer, "Bonus XP for a given submission", required: true)
353	xpAdjustment(:integer, "XP adjustment given", required: true)
354	adjustment(:integer, "Grade adjustment given", required: true)
355
356	status(
357	Schema.ref(:AssessmentStatus),
358	"One of 'not_attempted/attempting/attempted/submitted' indicating whether the assessment has been attempted by the current user",
359	required: true
360	)
361
362	gradedCount(:integer, "Number of questions in this submission that have been graded",
363	required: true
364	)
365
366	assessment(Schema.ref(:AssessmentInfo), "Assessment for which the submission is for",
367	required: true
368	)
369
370	student(
371	Schema.ref(:StudentInfo),
372	"Student who created the submission",
373	required: true
374	)
375
376	unsubmittedBy(Schema.ref(:GraderInfo))
377	unsubmittedAt(:string, "Last unsubmitted at", format: "date-time", required: false)
378
379	isGradingPublished(:boolean, "Whether the grading is published", required: true)	1✔
380	end
381	end,
382	AssessmentInfo:
383	swagger_schema do	1✔
384	properties do	1✔
385	id(:integer, "assessment id", required: true)
386
387	config(Schema.ref(:AssessmentConfig), "Either mission/sidequest/path/contest",
388	required: true
389	)
390
391	title(:string, "Mission title", required: true)
392
393	maxGrade(
394	:integer,
395	"The max grade for this assessment",
396	required: true
397	)
398
399	maxXp(
400	:integer,
401	"The max xp for this assessment",
402	required: true
403	)
404
405	questionCount(:integer, "number of questions in this assessment", required: true)	1✔
406	end
407	end,
408	StudentInfo:
409	swagger_schema do	1✔
410	properties do	1✔
411	id(:integer, "student id", required: true)
412	name(:string, "student name", required: true)
413	username(:string, "student username", required: true)
414	groupName(:string, "name of student's group")
415	groupLeaderId(:integer, "user id of group leader")	1✔
416	end
417	end,
418	GraderInfo:
419	swagger_schema do	1✔
420	properties do	1✔
421	id(:integer, "grader id", required: true)
422	name(:string, "grader name", required: true)	1✔
423	end
424	end,
425	GradingInfo:
426	swagger_schema do	1✔
427	description(
428	"A list of questions with submitted answers, solution and previous grading info " <>
429	"if available"
430	)
431
432	type(:array)
433
434	items(
435	Schema.new do	1✔
436	properties do	1✔
437	question(Schema.ref(:Question), "Question", required: true)
438	grade(Schema.ref(:Grade), "Grading information", required: true)
439	student(Schema.ref(:StudentInfo), "Student", required: true)
440
441	solution(
442	:string,
443	"the marking scheme and model solution to this question. Only available for programming questions",
444	required: true
445	)
446
447	maxGrade(
448	:integer,
449	"the max grade that can be given to this question",
450	required: true
451	)
452
453	maxXp(	1✔
454	:integer,
455	"the max xp that can be given to this question",
456	required: true
457	)
458	end
459	end
460	)
461	end,
462	GradingSummary:
463	swagger_schema do	1✔
464	description("Summary of grading items for current user as the grader")
465
466	properties do	1✔
467	groupName(:string, "Name of group this grader is in", required: true)
468	leaderName(:string, "Name of group leader", required: true)
469	submittedMissions(:integer, "Number of submitted missions", required: true)
470	submittedSidequests(:integer, "Number of submitted sidequests", required: true)
471	ungradedMissions(:integer, "Number of ungraded missions", required: true)
472	ungradedSidequests(:integer, "Number of ungraded sidequests", required: true)	1✔
473	end
474	end,
475	Grade:
476	swagger_schema do	1✔
477	properties do	1✔
478	grade(:integer, "Grade awarded by autograder")
479	xp(:integer, "XP awarded by autograder")
480	adjustment(:integer, "Grade adjustment given")
481	xpAdjustment(:integer, "XP adjustment given", required: true)
482	grader(Schema.ref(:GraderInfo))
483	gradedAt(:string, "Last graded at", format: "date-time", required: false)
484	comments(:string, "Comments given by grader")	1✔
485	end
486	end,
487	Grading:
488	swagger_schema do	1✔
489	properties do	1✔
490	grading(	1✔
491	Schema.new do	1✔
492	properties do	1✔
493	adjustment(:integer, "Grade adjustment given")
494	xpAdjustment(:integer, "XP adjustment given")
495	comments(:string, "Comments given by grader")	1✔
496	end
497	end
498	)
499	end
500	end
501	}
502	end
503	end

source-academy / backend / 410d0308186c400f57ab0fc2b05beda552c8fdd2-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