• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

MarkUsProject / Markus / 21737220433

06 Feb 2026 03:08AM UTC coverage: 91.707% (-0.01%) from 91.717%
21737220433

Pull #7815

github

web-flow
Merge 66ea8905e into 20f52eeb8
Pull Request #7815: build(deps): bump rails from 8.0.3 to 8.1.2

935 of 1829 branches covered (51.12%)

Branch coverage included in aggregate %.

6 of 7 new or added lines in 3 files covered. (85.71%)

5 existing lines in 2 files now uncovered.

44722 of 47957 relevant lines covered (93.25%)

123.33 hits per line

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

91.07
/app/controllers/api/groups_controller.rb
1
module Api
1✔
2
  # Allows for listing Markus groups for a particular assignment.
3
  # Uses Rails' RESTful routes (check 'rake routes' for the configured routes)
4
  class GroupsController < MainApiController
1✔
5
    # Define default fields to display for index and show methods
6
    DEFAULT_FIELDS = [:id, :group_name].freeze
1✔
7

8
    # Create an assignment's group
9
    # Requires: assignment_id
10
    # Optional: filter, fields
11
    def create
1✔
12
      assignment = Assignment.find(params[:assignment_id])
10✔
13
      begin
14
        group = assignment.add_group_api(params[:new_group_name], params[:members])
10✔
15
        respond_to do |format|
7✔
16
          format.xml do
7✔
17
            render xml: group.to_xml(root: 'group', skip_types: 'true')
7✔
18
          end
19
          format.json { render json: group.to_json }
7✔
20
        end
21
      rescue StandardError => e
22
        render 'shared/http_status', locals: { code: '422', message:
3✔
23
          e.message }, status: :unprocessable_content
24
      end
25
    end
26

27
    # Returns an assignment's groups along with their attributes
28
    # Requires: assignment_id
29
    # Optional: filter, fields
30
    def index
1✔
31
      groups = get_collection(assignment.groups) || return
12✔
32

33
      group_data = include_memberships(groups)
11✔
34

35
      respond_to do |format|
11✔
36
        format.xml do
11✔
37
          render xml: group_data.to_xml(root: 'groups', skip_types: 'true')
4✔
38
        end
39
        format.json { render json: group_data }
18✔
40
      end
41
    end
42

43
    # Returns a single group along with its attributes
44
    # Requires: id
45
    # Optional: fields
46
    def show
1✔
47
      group_data = include_memberships(Group.where(id: record.id))
6✔
48

49
      # We found a grouping for that assignment
50
      respond_to do |format|
6✔
51
        format.xml do
6✔
52
          render xml: group_data.to_xml(root: 'groups', skip_types: 'true')
3✔
53
        end
54
        format.json { render json: group_data }
9✔
55
      end
56
    end
57

58
    # Include student_memberships and user info
59
    def include_memberships(groups)
1✔
60
      groups.joins(groupings: [:assignment, { student_memberships: [:role] }])
17✔
61
            .where('assessments.id': params[:assignment_id])
62
            .pluck_to_hash(*DEFAULT_FIELDS, :membership_status, :role_id)
63
            .group_by { |h| h.slice(*DEFAULT_FIELDS) }
23✔
64
            .map { |k, v| k.merge(members: v.map { |h| h.except(*DEFAULT_FIELDS) }) }
46✔
65
    end
66

67
    def add_members
1✔
68
      if self.grouping.nil?
8✔
69
        # The group doesn't have a grouping associated with that assignment
70
        render 'shared/http_status', locals: { code: '422', message:
2✔
71
          'The group is not involved with that assignment' }, status: :unprocessable_content
72
        return
2✔
73
      end
74

75
      students = current_course.students.joins(:user).where('users.user_name': params[:members])
6✔
76
      students.each do |student|
6✔
77
        set_membership_status = if grouping.student_memberships.empty?
10✔
78
                                  StudentMembership::STATUSES[:inviter]
2✔
79
                                else
80
                                  StudentMembership::STATUSES[:accepted]
8✔
81
                                end
82
        grouping.invite(student.user_name, set_membership_status, invoked_by_instructor: true)
10✔
83
        grouping.reload
10✔
84
      end
85

86
      render 'shared/http_status', locals: { code: '200', message:
6✔
87
        HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
88
    end
89

90
    # Update the group's marks for the given assignment.
91
    def update_marks
1✔
92
      result = self.grouping&.current_submission_used&.get_latest_result
6✔
93
      return page_not_found('No submission exists for that group') if result.nil?
6✔
94

95
      # We shouldn't be able to update marks if marking is already complete.
96
      if result.marking_state == Result::MARKING_STATES[:complete]
6✔
97
        render 'shared/http_status', locals: { code: '404', message:
2✔
98
          'Marking for that submission is already completed' }, status: :not_found
99
        return
2✔
100
      end
101
      matched_criteria = assignment.criteria.where(name: params.keys)
4✔
102
      if matched_criteria.empty?
4✔
103
        render 'shared/http_status', locals: { code: '404', message:
×
104
          'No criteria were found that match that request.' }, status: :not_found
105
        return
×
106
      end
107

108
      matched_criteria.each do |crit|
4✔
109
        mark_to_change = result.marks.find_or_initialize_by(criterion_id: crit.id)
4✔
110
        mark_to_change.mark = params[crit.name] == 'nil' ? nil : params[crit.name].to_f
4✔
111
        unless mark_to_change.save
4✔
112
          # Some error occurred (including invalid mark)
113
          render 'shared/http_status', locals: { code: '500', message:
×
114
            mark_to_change.errors.full_messages.first }, status: :internal_server_error
115
          return
×
116
        end
117
      end
118
      result.save
4✔
119
      render 'shared/http_status', locals: { code: '200', message:
4✔
120
        HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
121
    end
122

123
    def create_extra_marks
1✔
124
      result = self.grouping&.current_submission_used&.get_latest_result
5✔
125
      return page_not_found('No submission exists for that group') if result.nil?
5✔
126

127
      begin
128
        ExtraMark.create!(result_id: result.id, extra_mark: params[:extra_marks],
4✔
129
                          description: params[:description], unit: ExtraMark::POINTS)
130
      rescue ActiveRecord::RecordInvalid => e
131
        # Some error occurred
132
        render 'shared/http_status', locals: { code: '500', message:
2✔
133
            e.message }, status: :internal_server_error
134
        return
2✔
135
      end
136
      render 'shared/http_status', locals: { code: '200', message:
2✔
137
          'Extra mark created successfully' }, status: :ok
138
    end
139

140
    def remove_extra_marks
1✔
141
      result = self.grouping&.current_submission_used&.get_latest_result
5✔
142
      return page_not_found('No submission exists for that group') if result.nil?
5✔
143
      extra_mark = ExtraMark.find_by(result_id: result.id,
4✔
144
                                     description: params[:description],
145
                                     extra_mark: params[:extra_marks])
146
      if extra_mark.nil?
4✔
147
        render 'shared/http_status', locals: { code: '404', message:
2✔
148
            'No such Extra Mark exist for that result' }, status: :not_found
149
        return
2✔
150
      end
151
      begin
152
        extra_mark.destroy
2✔
153
      rescue ActiveRecord::RecordNotDestroyed => e
154
        # Some other error occurred
155
        render 'shared/http_status', locals: { code: '500', message:
×
156
            e.message }, status: :internal_server_error
157
        return
×
158
      end
159
      # Successfully deleted the Extra Mark; render success
160
      render 'shared/http_status', locals: { code: '200', message:
2✔
161
          'Extra mark removed successfully' }, status: :ok
162
    end
163

164
    def annotations
1✔
165
      if record # this is a member route
2✔
166
        grouping_relation = assignment.groupings.where(group_id: record.id)
2✔
167
      else # this is a collection route
168
        grouping_relation = assignment.groupings
×
169
      end
170

171
      pluck_keys = ['annotations.type as type',
2✔
172
                    'annotation_texts.content as content',
173
                    'submission_files.filename as filename',
174
                    'submission_files.path as path',
175
                    'annotations.page as page',
176
                    'group_id',
177
                    'annotation_categories.annotation_category_name as category',
178
                    'annotations.creator_id as creator_id',
179
                    'annotation_texts.creator_id as content_creator_id',
180
                    'annotations.line_end as line_end',
181
                    'annotations.line_start as line_start',
182
                    'annotations.column_start as column_start',
183
                    'annotations.column_end as column_end',
184
                    'annotations.x1 as x1',
185
                    'annotations.y1 as y1',
186
                    'annotations.x2 as x2',
187
                    'annotations.y2 as y2']
188

189
      annotations = grouping_relation.left_joins(current_submission_used:
2✔
190
                                              [submission_files:
191
                                                 [annotations:
192
                                                    [annotation_text: :annotation_category]]])
193
                                     .where(assessment_id: params[:assignment_id])
194
                                     .where.not('annotations.id': nil)
195
                                     .pluck_to_hash(*pluck_keys)
196
      respond_to do |format|
2✔
197
        format.xml do
2✔
198
          render xml: annotations.to_xml(root: 'annotations', skip_types: 'true')
2✔
199
        end
200
        format.json do
2✔
201
          render json: annotations.to_json
×
202
        end
203
      end
204
    end
205

206
    def test_results
1✔
207
      return render_no_grouping_error unless grouping
10✔
208

209
      # Use the existing Assignment#summary_test_results method filtered for this specific group
210
      # This ensures format consistency with the UI download (summary_test_result_json)
211
      group_name = grouping.group.group_name
10✔
212
      results = assignment.summary_test_results([group_name])
10✔
213

214
      return render_no_grouping_error if results.blank?
10✔
215

216
      # Group by test_group name to match the summary_test_result_json format
217
      results_by_test_group = results.group_by(&:name)
9✔
218

219
      respond_to do |format|
9✔
220
        format.xml { render xml: results_by_test_group.to_xml(root: 'test_results', skip_types: 'true') }
11✔
221
        format.json { render json: results_by_test_group }
16✔
222
      end
223
    end
224

225
    def render_no_grouping_error
1✔
226
      render 'shared/http_status',
1✔
227
             locals: { code: '404', message: 'No test results found for this group' },
228
             status: :not_found
229
    end
230

231
    def add_annotations
1✔
232
      result = self.grouping&.current_result
1✔
233
      return page_not_found('No submission exists for that group') if result.nil?
1✔
234

235
      force_complete = params.fetch(:force_complete, false)
1✔
236
      # We shouldn't be able to update annotations if marking is already complete, unless forced.
237
      if result.marking_state == Result::MARKING_STATES[:complete] && !force_complete
1✔
238
        return page_not_found('Marking for that submission is already completed')
×
239
      end
240

241
      annotation_texts = []
1✔
242
      annotations = []
1✔
243
      count = result.submission.annotations.count + 1
1✔
244
      annotation_category = nil
1✔
245
      submission_file = nil
1✔
246
      params[:annotations].each_with_index do |annot_params, i|
1✔
247
        if annot_params[:annotation_category_name].nil?
2✔
248
          annotation_category_id = nil
2✔
249
        else
UNCOV
250
          name = annot_params[:annotation_category_name]
×
UNCOV
251
          if annotation_category.nil? || annotation_category.annotation_category_name != name
×
UNCOV
252
            annotation_category = assignment.annotation_categories.find_or_create_by(
×
253
              annotation_category_name: name
254
            )
255
          end
UNCOV
256
          annotation_category_id = annotation_category.id
×
257
        end
258
        if submission_file.nil? || submission_file.filename != annot_params[:filename]
2✔
259
          submission_file = result.submission.submission_files.find_by(filename: annot_params[:filename])
1✔
260
        end
261

262
        annotation_texts << {
2✔
263
          content: annot_params[:content],
264
          annotation_category_id: annotation_category_id,
265
          creator_id: current_role.id,
266
          last_editor_id: current_role.id
267
        }
268
        annotations << {
2✔
269
          line_start: annot_params[:line_start],
270
          line_end: annot_params[:line_end],
271
          column_start: annot_params[:column_start],
272
          column_end: annot_params[:column_end],
273
          annotation_text_id: nil,
274
          submission_file_id: submission_file.id,
275
          creator_id: current_role.id,
276
          creator_type: current_role.type,
277
          is_remark: !result.remark_request_submitted_at.nil?,
278
          annotation_number: count + i,
279
          result_id: result.id
280
        }
281
      end
282
      imported = AnnotationText.insert_all! annotation_texts
1✔
283
      imported.rows.zip(annotations) do |t, a|
1✔
284
        a[:annotation_text_id] = t[0]
2✔
285
      end
286
      TextAnnotation.insert_all! annotations
1✔
287
      render 'shared/http_status', locals: { code: '200', message:
1✔
288
        HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
289
    end
290

291
    # Return key:value pairs of group_name:group_id
292
    def group_ids_by_name
1✔
293
      reversed = assignment.groups.pluck(:group_name, :id).to_h
4✔
294
      respond_to do |format|
4✔
295
        format.xml do
4✔
296
          render xml: reversed.to_xml(root: 'groups', skip_types: 'true')
2✔
297
        end
298
        format.json do
4✔
299
          render json: reversed.to_json
2✔
300
        end
301
      end
302
    end
303

304
    # Allow user to set marking state to complete
305
    def update_marking_state
1✔
306
      if has_missing_params?([:marking_state])
4✔
307
        # incomplete/invalid HTTP params
308
        render 'shared/http_status', locals: { code: '422', message:
×
309
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
310
        return
×
311
      end
312
      result = self.grouping&.current_submission_used&.get_latest_result
4✔
313
      return page_not_found('No submission exists for that group') if result.nil?
4✔
314
      result.marking_state = params[:marking_state]
4✔
315
      if result.save
4✔
316
        render 'shared/http_status', locals: { code: '200', message:
4✔
317
            HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
318
      else
319
        render 'shared/http_status', locals: { code: '500', message:
×
320
            result.errors.full_messages.first }, status: :internal_server_error
321
      end
322
    end
323

324
    def add_tag
1✔
325
      grouping = self.grouping
2✔
326
      tag = self.assignment.tags.find_by(id: params[:tag_id])
2✔
327
      if tag.nil? || grouping.nil?
2✔
328
        raise 'tag or group not found'
1✔
329
      else
330
        grouping.tags << tag
1✔
331
        render 'shared/http_status', locals: { code: '200', message:
1✔
332
          HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
333
      end
334
    rescue StandardError
335
      render 'shared/http_status', locals: { code: '404', message: I18n.t('tags.not_found') }, status: :not_found
1✔
336
    end
337

338
    def remove_tag
1✔
339
      grouping = self.grouping
2✔
340
      tag = grouping.tags.find_by(id: params[:tag_id])
2✔
341
      if tag.nil? || grouping.nil?
2✔
342
        raise 'tag or grouping not found'
1✔
343
      else
344
        grouping.tags.destroy(tag)
1✔
345
        render 'shared/http_status', locals: { code: '200', message:
1✔
346
          HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
347
      end
348
    rescue StandardError
349
      render 'shared/http_status', locals: { code: '404', message: I18n.t('tags.not_found') }, status: :not_found
1✔
350
    end
351

352
    def extension
1✔
353
      grouping = Grouping.find_by(group_id: params[:id], assignment: params[:assignment_id])
12✔
354
      case request.method
12✔
355
      when 'DELETE'
356
        if grouping.extension.present?
2✔
357
          grouping.extension.destroy!
1✔
358
          # Successfully deleted the extension; render success
359
          render 'shared/http_status', locals: { code: '200', message:
1✔
360
            HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
361
        else
362
          # cannot delete a non existent extension; render failure
363
          render 'shared/http_status', locals: { code: '422', message:
1✔
364
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
365
        end
366
      when 'POST'
367
        if grouping.extension.nil?
5✔
368
          extension_values = extension_params
4✔
369
          extension_values[:time_delta] = time_delta_params if extension_values[:time_delta].present?
4✔
370
          grouping.create_extension!(extension_values)
4✔
371
          # Successfully created the extension record; render success
372
          render 'shared/http_status', locals: { code: '201', message:
2✔
373
            HttpStatusHelper::ERROR_CODE['message']['201'] }, status: :created
374
        else
375
          # cannot create extension as it already exists; render failure
376
          render 'shared/http_status', locals: { code: '422', message:
1✔
377
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
378
        end
379
      when 'PATCH'
380
        if grouping.extension.present?
4✔
381
          extension_values = extension_params
3✔
382
          extension_values[:time_delta] = time_delta_params if extension_values[:time_delta].present?
3✔
383
          grouping.extension.update!(extension_values)
3✔
384
          # Successfully updated the extension record; render success
385
          render 'shared/http_status', locals: { code: '200', message:
3✔
386
            HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
387
        else
388
          # cannot update extension as it does not exists; render failure
389
          render 'shared/http_status', locals: { code: '422', message:
1✔
390
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
391
        end
392
      end
393
    rescue ActiveRecord::RecordInvalid => e
394
      render 'shared/http_status', locals: { code: '422', message: e.to_s }, status: :unprocessable_content
2✔
395
    end
396

397
    def collect_submission
1✔
398
      @grouping = Grouping.find_by(group_id: params[:id], assignment: params[:assignment_id])
3✔
399
      unless @grouping.current_submission_used.nil?
3✔
400
        released = @grouping.current_submission_used.results.exists?(released_to_students: true)
1✔
401
        if released
1✔
402
          render 'shared/http_status', locals: { code: '422', message:
1✔
403
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
404
          return
1✔
405
        end
406
      end
407

408
      @revision_identifier = params[:revision_identifier]
2✔
409
      apply_late_penalty = if params[:apply_late_penalty].nil?
2✔
410
                             false
×
411
                           else
412
                             params[:apply_late_penalty]
2✔
413
                           end
414
      retain_existing_grading = if params[:retain_existing_grading].nil?
2✔
415
                                  false
×
416
                                else
417
                                  params[:retain_existing_grading]
2✔
418
                                end
419
      SubmissionsJob.perform_now([@grouping],
2✔
420
                                 revision_identifier: @revision_identifier,
421
                                 collect_current: params[:collect_current],
422
                                 apply_late_penalty: apply_late_penalty,
423
                                 retain_existing_grading: retain_existing_grading)
424

425
      render 'shared/http_status', locals: { code: '201', message:
2✔
426
        HttpStatusHelper::ERROR_CODE['message']['201'] }, status: :created
427
    end
428

429
    def add_test_run
1✔
430
      m_logger = MarkusLogger.instance
15✔
431
      # Validate test results against contract schema
432
      validation = TestResultsContract.new.call(params[:test_results].as_json)
15✔
433

434
      if validation.failure?
15✔
435
        return render json: { errors: validation.errors.to_hash }, status: :unprocessable_content
1✔
436
      end
437

438
      # Verify grouping exists and is authorized (grouping helper method handles this)
439
      if grouping.nil?
14✔
440
        return render json: { errors: 'Group not found for this assignment' }, status: :not_found
×
441
      end
442

443
      # Verify submission exists before attempting to create test run
444
      submission = grouping.current_submission_used
14✔
445
      if submission.nil?
14✔
446
        return render json: { errors: 'No submission exists for this grouping' }, status: :unprocessable_content
1✔
447
      end
448

449
      begin
450
        ActiveRecord::Base.transaction do
13✔
451
          test_run = TestRun.create!(
13✔
452
            status: :in_progress,
453
            role: current_role,
454
            grouping: grouping,
455
            submission: submission
456
          )
457

458
          test_run.update_results!(JSON.parse(params[:test_results].to_json))
10✔
459
          render json: { status: 'success', test_run_id: test_run.id }, status: :created
7✔
460
        end
461
      rescue ActiveRecord::RecordInvalid => e
462
        render json: { errors: e.record.errors.full_messages }, status: :unprocessable_content
3✔
463
      rescue StandardError => e
464
        m_logger.log("Test results processing failed: #{e.message}\n#{e.backtrace.join("\n")}")
3✔
465
        render json: { errors: 'Failed to process test results' }, status: :internal_server_error
3✔
466
      end
467
    end
468

469
    private
1✔
470

471
    def assignment
1✔
472
      return @assignment if defined?(@assignment)
91✔
473

474
      @assignment = Assignment.find_by(id: params[:assignment_id])
75✔
475
    end
476

477
    def grouping
1✔
478
      @grouping ||= record.grouping_for_assignment(assignment.id)
124✔
479
    end
480

481
    def annotations_params
1✔
482
      params.require(annotations: [
×
483
        :annotation_category_name,
484
        :column_end,
485
        :column_start,
486
        :content,
487
        :filename,
488
        :line_end,
489
        :line_start
490
      ])
491
    end
492

493
    def time_delta_params
1✔
494
      params = extension_params[:time_delta]
5✔
495
      Extension::PARTS.sum { |part| params[part].to_i.public_send(part) }
25✔
496
    end
497

498
    def extension_params
1✔
499
      params.require(:extension).permit({ time_delta: [:weeks, :days, :hours, :minutes] }, :apply_penalty, :note)
12✔
500
    end
501
  end
502
end
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc