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

MarkUsProject / Markus / 20143075828

11 Dec 2025 06:18PM UTC coverage: 91.513%. Remained the same
20143075828

Pull #7763

github

web-flow
Merge 9f55e660a into 3421ef3b2
Pull Request #7763: Release 2.9.0

914 of 1805 branches covered (50.64%)

Branch coverage included in aggregate %.

1584 of 1666 new or added lines in 108 files covered. (95.08%)

573 existing lines in 35 files now uncovered.

43650 of 46892 relevant lines covered (93.09%)

121.63 hits per line

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

92.02
/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 add_annotations
1✔
207
      result = self.grouping&.current_result
1✔
208
      return page_not_found('No submission exists for that group') if result.nil?
1✔
209

210
      force_complete = params.fetch(:force_complete, false)
1✔
211
      # We shouldn't be able to update annotations if marking is already complete, unless forced.
212
      if result.marking_state == Result::MARKING_STATES[:complete] && !force_complete
1✔
213
        return page_not_found('Marking for that submission is already completed')
×
214
      end
215

216
      annotation_texts = []
1✔
217
      annotations = []
1✔
218
      count = result.submission.annotations.count + 1
1✔
219
      annotation_category = nil
1✔
220
      submission_file = nil
1✔
221
      params[:annotations].each_with_index do |annot_params, i|
1✔
222
        if annot_params[:annotation_category_name].nil?
2✔
223
          annotation_category_id = nil
×
224
        else
225
          name = annot_params[:annotation_category_name]
2✔
226
          if annotation_category.nil? || annotation_category.annotation_category_name != name
2✔
227
            annotation_category = assignment.annotation_categories.find_or_create_by(
1✔
228
              annotation_category_name: name
229
            )
230
          end
231
          annotation_category_id = annotation_category.id
2✔
232
        end
233
        if submission_file.nil? || submission_file.filename != annot_params[:filename]
2✔
234
          submission_file = result.submission.submission_files.find_by(filename: annot_params[:filename])
1✔
235
        end
236

237
        annotation_texts << {
2✔
238
          content: annot_params[:content],
239
          annotation_category_id: annotation_category_id,
240
          creator_id: current_role.id,
241
          last_editor_id: current_role.id
242
        }
243
        annotations << {
2✔
244
          line_start: annot_params[:line_start],
245
          line_end: annot_params[:line_end],
246
          column_start: annot_params[:column_start],
247
          column_end: annot_params[:column_end],
248
          annotation_text_id: nil,
249
          submission_file_id: submission_file.id,
250
          creator_id: current_role.id,
251
          creator_type: current_role.type,
252
          is_remark: !result.remark_request_submitted_at.nil?,
253
          annotation_number: count + i,
254
          result_id: result.id
255
        }
256
      end
257
      imported = AnnotationText.insert_all! annotation_texts
1✔
258
      imported.rows.zip(annotations) do |t, a|
1✔
259
        a[:annotation_text_id] = t[0]
2✔
260
      end
261
      TextAnnotation.insert_all! annotations
1✔
262
      render 'shared/http_status', locals: { code: '200', message:
1✔
263
        HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
264
    end
265

266
    # Return key:value pairs of group_name:group_id
267
    def group_ids_by_name
1✔
268
      reversed = assignment.groups.pluck(:group_name, :id).to_h
4✔
269
      respond_to do |format|
4✔
270
        format.xml do
4✔
271
          render xml: reversed.to_xml(root: 'groups', skip_types: 'true')
2✔
272
        end
273
        format.json do
4✔
274
          render json: reversed.to_json
2✔
275
        end
276
      end
277
    end
278

279
    # Allow user to set marking state to complete
280
    def update_marking_state
1✔
281
      if has_missing_params?([:marking_state])
4✔
282
        # incomplete/invalid HTTP params
283
        render 'shared/http_status', locals: { code: '422', message:
×
284
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
285
        return
×
286
      end
287
      result = self.grouping&.current_submission_used&.get_latest_result
4✔
288
      return page_not_found('No submission exists for that group') if result.nil?
4✔
289
      result.marking_state = params[:marking_state]
4✔
290
      if result.save
4✔
291
        render 'shared/http_status', locals: { code: '200', message:
4✔
292
            HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
293
      else
294
        render 'shared/http_status', locals: { code: '500', message:
×
295
            result.errors.full_messages.first }, status: :internal_server_error
296
      end
297
    end
298

299
    def add_tag
1✔
300
      grouping = self.grouping
2✔
301
      tag = self.assignment.tags.find_by(id: params[:tag_id])
2✔
302
      if tag.nil? || grouping.nil?
2✔
303
        raise 'tag or group not found'
1✔
304
      else
305
        grouping.tags << tag
1✔
306
        render 'shared/http_status', locals: { code: '200', message:
1✔
307
          HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
308
      end
309
    rescue StandardError
310
      render 'shared/http_status', locals: { code: '404', message: I18n.t('tags.not_found') }, status: :not_found
1✔
311
    end
312

313
    def remove_tag
1✔
314
      grouping = self.grouping
2✔
315
      tag = grouping.tags.find_by(id: params[:tag_id])
2✔
316
      if tag.nil? || grouping.nil?
2✔
317
        raise 'tag or grouping not found'
1✔
318
      else
319
        grouping.tags.destroy(tag)
1✔
320
        render 'shared/http_status', locals: { code: '200', message:
1✔
321
          HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
322
      end
323
    rescue StandardError
324
      render 'shared/http_status', locals: { code: '404', message: I18n.t('tags.not_found') }, status: :not_found
1✔
325
    end
326

327
    def extension
1✔
328
      grouping = Grouping.find_by(group_id: params[:id], assignment: params[:assignment_id])
12✔
329
      case request.method
12✔
330
      when 'DELETE'
331
        if grouping.extension.present?
2✔
332
          grouping.extension.destroy!
1✔
333
          # Successfully deleted the extension; render success
334
          render 'shared/http_status', locals: { code: '200', message:
1✔
335
            HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
336
        else
337
          # cannot delete a non existent extension; render failure
338
          render 'shared/http_status', locals: { code: '422', message:
1✔
339
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
340
        end
341
      when 'POST'
342
        if grouping.extension.nil?
5✔
343
          extension_values = extension_params
4✔
344
          extension_values[:time_delta] = time_delta_params if extension_values[:time_delta].present?
4✔
345
          grouping.create_extension!(extension_values)
4✔
346
          # Successfully created the extension record; render success
347
          render 'shared/http_status', locals: { code: '201', message:
2✔
348
            HttpStatusHelper::ERROR_CODE['message']['201'] }, status: :created
349
        else
350
          # cannot create extension as it already exists; render failure
351
          render 'shared/http_status', locals: { code: '422', message:
1✔
352
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
353
        end
354
      when 'PATCH'
355
        if grouping.extension.present?
4✔
356
          extension_values = extension_params
3✔
357
          extension_values[:time_delta] = time_delta_params if extension_values[:time_delta].present?
3✔
358
          grouping.extension.update!(extension_values)
3✔
359
          # Successfully updated the extension record; render success
360
          render 'shared/http_status', locals: { code: '200', message:
3✔
361
            HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
362
        else
363
          # cannot update extension as it does not exists; render failure
364
          render 'shared/http_status', locals: { code: '422', message:
1✔
365
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
366
        end
367
      end
368
    rescue ActiveRecord::RecordInvalid => e
369
      render 'shared/http_status', locals: { code: '422', message: e.to_s }, status: :unprocessable_content
2✔
370
    end
371

372
    def collect_submission
1✔
373
      @grouping = Grouping.find_by(group_id: params[:id], assignment: params[:assignment_id])
3✔
374
      unless @grouping.current_submission_used.nil?
3✔
375
        released = @grouping.current_submission_used.results.exists?(released_to_students: true)
1✔
376
        if released
1✔
377
          render 'shared/http_status', locals: { code: '422', message:
1✔
378
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
379
          return
1✔
380
        end
381
      end
382

383
      @revision_identifier = params[:revision_identifier]
2✔
384
      apply_late_penalty = if params[:apply_late_penalty].nil?
2✔
385
                             false
×
386
                           else
387
                             params[:apply_late_penalty]
2✔
388
                           end
389
      retain_existing_grading = if params[:retain_existing_grading].nil?
2✔
390
                                  false
×
391
                                else
392
                                  params[:retain_existing_grading]
2✔
393
                                end
394
      SubmissionsJob.perform_now([@grouping],
2✔
395
                                 revision_identifier: @revision_identifier,
396
                                 collect_current: params[:collect_current],
397
                                 apply_late_penalty: apply_late_penalty,
398
                                 retain_existing_grading: retain_existing_grading)
399

400
      render 'shared/http_status', locals: { code: '201', message:
2✔
401
        HttpStatusHelper::ERROR_CODE['message']['201'] }, status: :created
402
    end
403

404
    def add_test_run
1✔
405
      m_logger = MarkusLogger.instance
15✔
406
      # Validate test results against contract schema
407
      validation = TestResultsContract.new.call(params[:test_results].as_json)
15✔
408

409
      if validation.failure?
15✔
410
        return render json: { errors: validation.errors.to_hash }, status: :unprocessable_content
1✔
411
      end
412

413
      # Verify grouping exists and is authorized (grouping helper method handles this)
414
      if grouping.nil?
14✔
NEW
415
        return render json: { errors: 'Group not found for this assignment' }, status: :not_found
×
416
      end
417

418
      # Verify submission exists before attempting to create test run
419
      submission = grouping.current_submission_used
14✔
420
      if submission.nil?
14✔
421
        return render json: { errors: 'No submission exists for this grouping' }, status: :unprocessable_content
1✔
422
      end
423

424
      begin
425
        ActiveRecord::Base.transaction do
13✔
426
          test_run = TestRun.create!(
13✔
427
            status: :in_progress,
428
            role: current_role,
429
            grouping: grouping,
430
            submission: submission
431
          )
432

433
          test_run.update_results!(JSON.parse(params[:test_results].to_json))
10✔
434
          render json: { status: 'success', test_run_id: test_run.id }, status: :created
7✔
435
        end
436
      rescue ActiveRecord::RecordInvalid => e
437
        render json: { errors: e.record.errors.full_messages }, status: :unprocessable_content
3✔
438
      rescue StandardError => e
439
        m_logger.log("Test results processing failed: #{e.message}\n#{e.backtrace.join("\n")}")
3✔
440
        render json: { errors: 'Failed to process test results' }, status: :internal_server_error
3✔
441
      end
442
    end
443

444
    private
1✔
445

446
    def assignment
1✔
447
      return @assignment if defined?(@assignment)
72✔
448

449
      @assignment = Assignment.find_by(id: params[:assignment_id])
65✔
450
    end
451

452
    def grouping
1✔
453
      @grouping ||= record.grouping_for_assignment(assignment.id)
104✔
454
    end
455

456
    def annotations_params
1✔
457
      params.require(annotations: [
×
458
        :annotation_category_name,
459
        :column_end,
460
        :column_start,
461
        :content,
462
        :filename,
463
        :line_end,
464
        :line_start
465
      ])
466
    end
467

468
    def time_delta_params
1✔
469
      params = extension_params[:time_delta]
5✔
470
      Extension::PARTS.sum { |part| params[part].to_i.public_send(part) }
25✔
471
    end
472

473
    def extension_params
1✔
474
      params.require(:extension).permit({ time_delta: [:weeks, :days, :hours, :minutes] }, :apply_penalty, :note)
12✔
475
    end
476
  end
477
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

© 2025 Coveralls, Inc