26311291577

Committed 22 May 2026 08:49PM UTC coverage: 90.237% (+0.01%) from 90.225%

Build # 26311291577

Build Type

Pull #7963

github

Committed by

web-flow

Commit Message

Merge 84ce6893f into 26f0f60e5

Pull Request Pull Request #7963: Implement GET and PATCH /overall_comment API routes, closes #7708

Coverage Stats

971 of 2151 branches covered (45.14%)

Branch coverage included in aggregate %.

71 of 72 new or added lines in 3 files covered. (98.61%)

1 existing line in 1 file now uncovered.

45934 of 49829 relevant lines covered (92.18%)

128.14 hits per line

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

91.06

/app/controllers/api/groups_controller.rb

module Api
  # Allows for listing Markus groups for a particular assignment.
  # Uses Rails' RESTful routes (check 'rake routes' for the configured routes)
  class GroupsController < MainApiController
    # Define default fields to display for index and show methods
    DEFAULT_FIELDS = [:id, :group_name].freeze

    # Create an assignment's group
    # Requires: assignment_id
    # Optional: filter, fields
    def create
      assignment = Assignment.find(params[:assignment_id])
      begin
        group = assignment.add_group_api(params[:new_group_name], params[:members])
        respond_to do |format|
          format.xml do
            render xml: group.to_xml(root: 'group', skip_types: 'true')
          end
          format.json { render json: group.to_json }
        end
      rescue StandardError => e
        render 'shared/http_status', locals: { code: '422', message:
          e.message }, status: :unprocessable_content
      end
    end

    # Returns an assignment's groups along with their attributes
    # Requires: assignment_id
    # Optional: filter, fields
    def index
      groups = get_collection(assignment.groups) || return

      group_data = include_memberships(groups)

      respond_to do |format|
        format.xml do
          render xml: group_data.to_xml(root: 'groups', skip_types: 'true')
        end
        format.json { render json: group_data }
      end
    end

    # Returns a single group along with its attributes
    # Requires: id
    # Optional: fields
    def show
      group_data = include_memberships(Group.where(id: record.id))

      # We found a grouping for that assignment
      respond_to do |format|
        format.xml do
          render xml: group_data.to_xml(root: 'groups', skip_types: 'true')
        end
        format.json { render json: group_data }
      end
    end

    # Include student_memberships and user info
    def include_memberships(groups)
      groups.joins(groupings: [:assignment, { student_memberships: [:role] }])
            .where('assessments.id': params[:assignment_id])
            .pluck_to_hash(*DEFAULT_FIELDS, :membership_status, :role_id)
            .group_by { |h| h.slice(*DEFAULT_FIELDS) }
            .map { |k, v| k.merge(members: v.map { |h| h.except(*DEFAULT_FIELDS) }) }
    end

    def add_members
      if self.grouping.nil?
        # The group doesn't have a grouping associated with that assignment
        render 'shared/http_status', locals: { code: '422', message:
          'The group is not involved with that assignment' }, status: :unprocessable_content
        return
      end

      students = current_course.students.joins(:user).where('users.user_name': params[:members])
      students.each do |student|
        set_membership_status = if grouping.student_memberships.empty?
                                  StudentMembership::STATUSES[:inviter]
                                else
                                  StudentMembership::STATUSES[:accepted]
                                end
        grouping.invite(student.user_name, set_membership_status, invoked_by_instructor: true)
        grouping.reload
      end

      render 'shared/http_status', locals: { code: '200', message:
        HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
    end

    # Update the group's marks for the given assignment.
    def update_marks
      result = self.grouping&.current_submission_used&.get_latest_result
      return page_not_found('No submission exists for that group') if result.nil?

      # We shouldn't be able to update marks if marking is already complete.
      if result.marking_state == Result::MARKING_STATES[:complete]
        render 'shared/http_status', locals: { code: '404', message:
          'Marking for that submission is already completed' }, status: :not_found
        return
      end
      matched_criteria = assignment.criteria.where(name: params.keys)
      if matched_criteria.empty?
        render 'shared/http_status', locals: { code: '404', message:
          'No criteria were found that match that request.' }, status: :not_found
        return
      end

      matched_criteria.each do |crit|
        mark_to_change = result.marks.find_or_initialize_by(criterion_id: crit.id)
        mark_to_change.mark = params[crit.name] == 'nil' ? nil : params[crit.name].to_f
        unless mark_to_change.save
          # Some error occurred (including invalid mark)
          render 'shared/http_status', locals: { code: '500', message:
            mark_to_change.errors.full_messages.first }, status: :internal_server_error
          return
        end
      end
      result.save
      render 'shared/http_status', locals: { code: '200', message:
        HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
    end

    def create_extra_marks
      result = self.grouping&.current_submission_used&.get_latest_result
      return page_not_found('No submission exists for that group') if result.nil?

      begin
        ExtraMark.create!(result_id: result.id, extra_mark: params[:extra_marks],
                          description: params[:description], unit: ExtraMark::POINTS)
      rescue ActiveRecord::RecordInvalid => e
        # Some error occurred
        render 'shared/http_status', locals: { code: '500', message:
            e.message }, status: :internal_server_error
        return
      end
      render 'shared/http_status', locals: { code: '200', message:
          'Extra mark created successfully' }, status: :ok
    end

    def remove_extra_marks
      result = self.grouping&.current_submission_used&.get_latest_result
      return page_not_found('No submission exists for that group') if result.nil?
      extra_mark = ExtraMark.find_by(result_id: result.id,
                                     description: params[:description],
                                     extra_mark: params[:extra_marks])
      if extra_mark.nil?
        render 'shared/http_status', locals: { code: '404', message:
            'No such Extra Mark exist for that result' }, status: :not_found
        return
      end
      begin
        extra_mark.destroy
      rescue ActiveRecord::RecordNotDestroyed => e
        # Some other error occurred
        render 'shared/http_status', locals: { code: '500', message:
            e.message }, status: :internal_server_error
        return
      end
      # Successfully deleted the Extra Mark; render success
      render 'shared/http_status', locals: { code: '200', message:
          'Extra mark removed successfully' }, status: :ok
    end

    def annotations
      if record # this is a member route
        grouping_relation = assignment.groupings.where(group_id: record.id)
      else # this is a collection route
        grouping_relation = assignment.groupings
      end

      pluck_keys = ['annotations.type as type',
                    'annotation_texts.content as content',
                    'submission_files.filename as filename',
                    'submission_files.path as path',
                    'annotations.page as page',
                    'group_id',
                    'annotation_categories.annotation_category_name as category',
                    'annotations.creator_id as creator_id',
                    'annotation_texts.creator_id as content_creator_id',
                    'annotations.line_end as line_end',
                    'annotations.line_start as line_start',
                    'annotations.column_start as column_start',
                    'annotations.column_end as column_end',
                    'annotations.x1 as x1',
                    'annotations.y1 as y1',
                    'annotations.x2 as x2',
                    'annotations.y2 as y2']

      annotations = grouping_relation.left_joins(current_submission_used:
                                              [{ submission_files:
                                                 [{ annotations:
                                                    [{ annotation_text: :annotation_category }] }] }])
                                     .where(assessment_id: params[:assignment_id])
                                     .where.not('annotations.id': nil)
                                     .pluck_to_hash(*pluck_keys)
      respond_to do |format|
        format.xml do
          render xml: annotations.to_xml(root: 'annotations', skip_types: 'true')
        end
        format.json do
          render json: annotations.to_json
        end
      end
    end

    def test_results
      return render_no_grouping_error unless grouping

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

      return render_no_grouping_error if results.blank?

      # Group by test_group name to match the summary_test_result_json format
      results_by_test_group = results.group_by(&:name)

      respond_to do |format|
        format.xml { render xml: results_by_test_group.to_xml(root: 'test_results', skip_types: 'true') }
        format.json { render json: results_by_test_group }
      end
    end

    def render_no_grouping_error
      render 'shared/http_status',
             locals: { code: '404', message: 'No test results found for this group' },
             status: :not_found
    end

    def add_annotations
      result = self.grouping&.current_result
      return page_not_found('No submission exists for that group') if result.nil?

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

      annotation_texts = []
      annotations = []
      count = result.submission.annotations.count + 1
      annotation_category = nil
      submission_file = nil
      params[:annotations].each_with_index do |annot_params, i|
        if annot_params[:annotation_category_name].nil?
          annotation_category_id = nil
        else
          name = annot_params[:annotation_category_name]
          if annotation_category.nil? || annotation_category.annotation_category_name != name
            annotation_category = assignment.annotation_categories.find_or_create_by(
              annotation_category_name: name
            )
          end
          annotation_category_id = annotation_category.id
        end
        if submission_file.nil? || submission_file.filename != annot_params[:filename]
          submission_file = result.submission.submission_files.find_by(filename: annot_params[:filename])
        end

        annotation_texts << {
          content: annot_params[:content],
          annotation_category_id: annotation_category_id,
          creator_id: current_role.id,
          last_editor_id: current_role.id
        }
        annotations << {
          line_start: annot_params[:line_start],
          line_end: annot_params[:line_end],
          column_start: annot_params[:column_start],
          column_end: annot_params[:column_end],
          annotation_text_id: nil,
          submission_file_id: submission_file.id,
          creator_id: current_role.id,
          creator_type: current_role.type,
          is_remark: !result.remark_request_submitted_at.nil?,
          annotation_number: count + i,
          result_id: result.id
        }
      end
      imported = AnnotationText.insert_all! annotation_texts
      imported.rows.zip(annotations) do |t, a|
        a[:annotation_text_id] = t[0]
      end
      TextAnnotation.insert_all! annotations
      render 'shared/http_status', locals: { code: '200', message:
        HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
    end

    # Return key:value pairs of group_name:group_id
    def group_ids_by_name
      reversed = assignment.groups.pluck(:group_name, :id).to_h
      respond_to do |format|
        format.xml do
          render xml: reversed.to_xml(root: 'groups', skip_types: 'true')
        end
        format.json do
          render json: reversed.to_json
        end
      end
    end

    # Allow user to set marking state to complete
    def update_marking_state
      if has_missing_params?([:marking_state])
        # incomplete/invalid HTTP params
        render 'shared/http_status', locals: { code: '422', message:
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
        return
      end
      result = self.grouping&.current_submission_used&.get_latest_result
      return page_not_found('No submission exists for that group') if result.nil?
      result.marking_state = params[:marking_state]
      if result.save
        render 'shared/http_status', locals: { code: '200', message:
            HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
      else
        render 'shared/http_status', locals: { code: '500', message:
            result.errors.full_messages.first }, status: :internal_server_error
      end
    end

    def add_tag
      grouping = self.grouping
      tag = self.assignment.tags.find_by(id: params[:tag_id])
      if tag.nil? || grouping.nil?
        raise 'tag or group not found'
      else
        grouping.tags << tag
        render 'shared/http_status', locals: { code: '200', message:
          HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
      end
    rescue StandardError
      render 'shared/http_status', locals: { code: '404', message: I18n.t('tags.not_found') }, status: :not_found
    end

    def remove_tag
      grouping = self.grouping
      tag = grouping.tags.find_by(id: params[:tag_id])
      if tag.nil? || grouping.nil?
        raise 'tag or grouping not found'
      else
        grouping.tags.destroy(tag)
        render 'shared/http_status', locals: { code: '200', message:
          HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
      end
    rescue StandardError
      render 'shared/http_status', locals: { code: '404', message: I18n.t('tags.not_found') }, status: :not_found
    end

    def extension
      grouping = Grouping.find_by(group_id: params[:id], assignment: params[:assignment_id])
      case request.method
      when 'DELETE'
        if grouping.extension.present?
          grouping.extension.destroy!
          # Successfully deleted the extension; render success
          render 'shared/http_status', locals: { code: '200', message:
            HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
        else
          # cannot delete a non existent extension; render failure
          render 'shared/http_status', locals: { code: '422', message:
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
        end
      when 'POST'
        if grouping.extension.nil?
          extension_values = extension_params
          extension_values[:time_delta] = time_delta_params if extension_values[:time_delta].present?
          grouping.create_extension!(extension_values)
          # Successfully created the extension record; render success
          render 'shared/http_status', locals: { code: '201', message:
            HttpStatusHelper::ERROR_CODE['message']['201'] }, status: :created
        else
          # cannot create extension as it already exists; render failure
          render 'shared/http_status', locals: { code: '422', message:
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
        end
      when 'PATCH'
        if grouping.extension.present?
          extension_values = extension_params
          extension_values[:time_delta] = time_delta_params if extension_values[:time_delta].present?
          grouping.extension.update!(extension_values)
          # Successfully updated the extension record; render success
          render 'shared/http_status', locals: { code: '200', message:
            HttpStatusHelper::ERROR_CODE['message']['200'] }, status: :ok
        else
          # cannot update extension as it does not exists; render failure
          render 'shared/http_status', locals: { code: '422', message:
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
        end
      end
    rescue ActiveRecord::RecordInvalid => e
      render 'shared/http_status', locals: { code: '422', message: e.to_s }, status: :unprocessable_content
    end

    def collect_submission
      @grouping = Grouping.find_by(group_id: params[:id], assignment: params[:assignment_id])
      unless @grouping.current_submission_used.nil?
        released = @grouping.current_submission_used.results.exists?(released_to_students: true)
        if released
          render 'shared/http_status', locals: { code: '422', message:
            HttpStatusHelper::ERROR_CODE['message']['422'] }, status: :unprocessable_content
          return
        end
      end

      @revision_identifier = params[:revision_identifier]
      apply_late_penalty = if params[:apply_late_penalty].nil?
                             false
                           else
                             params[:apply_late_penalty]
                           end
      retain_existing_grading = if params[:retain_existing_grading].nil?
                                  false
                                else
                                  params[:retain_existing_grading]
                                end
      SubmissionsJob.perform_now([@grouping],
                                 revision_identifier: @revision_identifier,
                                 collect_current: params[:collect_current],
                                 apply_late_penalty: apply_late_penalty,
                                 retain_existing_grading: retain_existing_grading)

      render 'shared/http_status', locals: { code: '201', message:
        HttpStatusHelper::ERROR_CODE['message']['201'] }, status: :created
    end

    def add_test_run
      m_logger = MarkusLogger.instance
      # Validate test results against contract schema
      validation = TestResultsContract.new.call(params[:test_results].as_json)

      if validation.failure?
        return render json: { errors: validation.errors.to_hash }, status: :unprocessable_content
      end

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

      # Verify submission exists before attempting to create test run
      submission = grouping.current_submission_used
      if submission.nil?
        return render json: { errors: 'No submission exists for this grouping' }, status: :unprocessable_content
      end

      begin
        ActiveRecord::Base.transaction do
          test_run = TestRun.create!(
            status: :in_progress,
            role: current_role,
            grouping: grouping,
            submission: submission
          )

          test_run.update_results!(JSON.parse(params[:test_results].to_json))
          render json: { status: 'success', test_run_id: test_run.id }, status: :created
        end
      rescue ActiveRecord::RecordInvalid => e
        render json: { errors: e.record.errors.full_messages }, status: :unprocessable_content
      rescue StandardError => e
        m_logger.log("Test results processing failed: #{e.message}\n#{e.backtrace.join("\n")}")
        render json: { errors: 'Failed to process test results' }, status: :internal_server_error
      end
    end

    def overall_comment
      result = grouping&.current_result
      return page_not_found('No submission exists for that group') if result.nil?

      case request.method
      when 'GET'
        respond_to do |format|
          format.xml do
 render xml: { overall_comment: result.overall_comment }.to_xml(root: 'result', skip_types: 'true')
          end
          format.json { render json: { overall_comment: result.overall_comment } }
        end
      when 'PATCH'
        if result.update(overall_comment: params[:overall_comment])
          head :ok
        else
          render 'shared/http_status',
                 locals: { code: '422', message: result.errors.full_messages.first },
                 status: :unprocessable_content
        end
      end
    end

    private

    def assignment
      return @assignment if defined?(@assignment)

      @assignment = Assignment.find_by(id: params[:assignment_id])
    end

    def grouping
      @grouping ||= record.grouping_for_assignment(assignment.id)
    end

    def annotations_params
      params.require(annotations: [
        :annotation_category_name,
        :column_end,
        :column_start,
        :content,
        :filename,
        :line_end,
        :line_start
      ])
    end

    def time_delta_params
      params = extension_params[:time_delta]
      Extension::PARTS.sum { |part| params[part].to_i.public_send(part) }
    end

    def extension_params
      params.require(:extension).permit({ time_delta: [:weeks, :days, :hours, :minutes] }, :apply_penalty, :note)
    end
  end
end

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
250	name = annot_params[:annotation_category_name]	×
251	if annotation_category.nil? \|\| annotation_category.annotation_category_name != name	×
252	annotation_category = assignment.annotation_categories.find_or_create_by(	×
253	annotation_category_name: name
254	)
255	end
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	def overall_comment	1✔
470	result = grouping&.current_result	9✔
471	return page_not_found('No submission exists for that group') if result.nil?	9✔
472
473	case request.method	7✔
474	when 'GET'
475	respond_to do \|format\|	5✔
476	format.xml do	5✔
477	render xml: { overall_comment: result.overall_comment }.to_xml(root: 'result', skip_types: 'true')	3✔
478	end
479	format.json { render json: { overall_comment: result.overall_comment } }	7✔
480	end
481	when 'PATCH'
482	if result.update(overall_comment: params[:overall_comment])	2✔
483	head :ok	2✔
484	else
NEW 485	render 'shared/http_status',	×
486	locals: { code: '422', message: result.errors.full_messages.first },
487	status: :unprocessable_content
488	end
489	end
490	end
491
492	private	1✔
493
494	def assignment	1✔
495	return @assignment if defined?(@assignment)	100✔
496
497	@assignment = Assignment.find_by(id: params[:assignment_id])	84✔
498	end
499
500	def grouping	1✔
501	@grouping \|\|= record.grouping_for_assignment(assignment.id)	133✔
502	end
503
504	def annotations_params	1✔
UNCOV 505	params.require(annotations: [	×
506	:annotation_category_name,
507	:column_end,
508	:column_start,
509	:content,
510	:filename,
511	:line_end,
512	:line_start
513	])
514	end
515
516	def time_delta_params	1✔
517	params = extension_params[:time_delta]	5✔
518	Extension::PARTS.sum { \|part\| params[part].to_i.public_send(part) }	25✔
519	end
520
521	def extension_params	1✔
522	params.require(:extension).permit({ time_delta: [:weeks, :days, :hours, :minutes] }, :apply_penalty, :note)	12✔
523	end
524	end
525	end

MarkUsProject / Markus / 26311291577

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