merged with current master

app/controllers/concerns/submission_scoring.rb

@@ -8,7 +8,15 @@ module SubmissionScoring
         output = execute_test_file(file, submission)
         assessment = assessor.assess(output)
         passed = ((assessment[:passed] == assessment[:count]) and (assessment[:score] > 0))
-        testrun_output = passed ? nil : output[:stderr]
+        testrun_output = passed ? nil : 'message: ' + output[:message].to_s + "\n stdout: " + output[:stdout].to_s + "\n stderr: " + output[:stderr].to_s
+        if !testrun_output.blank?
+          submission.exercise.execution_environment.error_templates.each do |template|
+            pattern = Regexp.new(template.signature).freeze
+            if pattern.match(testrun_output)
+              StructuredError.create_from_template(template, testrun_output)
+            end
+          end
+        end
         Testrun.new(submission: submission, cause: 'assess', file: file, passed: passed, output: testrun_output).save
         output.merge!(assessment)
         output.merge!(filename: file.name_with_extension, message: feedback_message(file, output[:score]), weight: file.weight)

app/controllers/error_template_attributes_controller.rb

@@ -0,0 +1,86 @@
+class ErrorTemplateAttributesController < ApplicationController
+  before_action :set_error_template_attribute, only: [:show, :edit, :update, :destroy]
+
+  def authorize!
+    authorize(@error_template_attributes || @error_template_attribute)
+  end
+  private :authorize!
+
+  # GET /error_template_attributes
+  # GET /error_template_attributes.json
+  def index
+    @error_template_attributes = ErrorTemplateAttribute.all.order('important DESC', :key, :id).paginate(page: params[:page])
+    authorize!
+  end
+
+  # GET /error_template_attributes/1
+  # GET /error_template_attributes/1.json
+  def show
+    authorize!
+  end
+
+  # GET /error_template_attributes/new
+  def new
+    @error_template_attribute = ErrorTemplateAttribute.new
+    authorize!
+  end
+
+  # GET /error_template_attributes/1/edit
+  def edit
+    authorize!
+  end
+
+  # POST /error_template_attributes
+  # POST /error_template_attributes.json
+  def create
+    @error_template_attribute = ErrorTemplateAttribute.new(error_template_attribute_params)
+    authorize!
+
+    respond_to do |format|
+      if @error_template_attribute.save
+        format.html { redirect_to @error_template_attribute, notice: 'Error template attribute was successfully created.' }
+        format.json { render :show, status: :created, location: @error_template_attribute }
+      else
+        format.html { render :new }
+        format.json { render json: @error_template_attribute.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /error_template_attributes/1
+  # PATCH/PUT /error_template_attributes/1.json
+  def update
+    authorize!
+    respond_to do |format|
+      if @error_template_attribute.update(error_template_attribute_params)
+        format.html { redirect_to @error_template_attribute, notice: 'Error template attribute was successfully updated.' }
+        format.json { render :show, status: :ok, location: @error_template_attribute }
+      else
+        format.html { render :edit }
+        format.json { render json: @error_template_attribute.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /error_template_attributes/1
+  # DELETE /error_template_attributes/1.json
+  def destroy
+    authorize!
+    @error_template_attribute.destroy
+    respond_to do |format|
+      format.html { redirect_to error_template_attributes_url, notice: 'Error template attribute was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_error_template_attribute
+      @error_template_attribute = ErrorTemplateAttribute.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def error_template_attribute_params
+      params[:error_template_attribute].permit(:key, :description, :regex, :important)
+    end
+end

app/controllers/error_templates_controller.rb

@@ -0,0 +1,104 @@
+class ErrorTemplatesController < ApplicationController
+  before_action :set_error_template, only: [:show, :edit, :update, :destroy, :add_attribute, :remove_attribute]
+
+  def authorize!
+    authorize(@error_templates || @error_template)
+  end
+  private :authorize!
+
+  # GET /error_templates
+  # GET /error_templates.json
+  def index
+    @error_templates = ErrorTemplate.all.order(:execution_environment_id, :name).paginate(page: params[:page])
+    authorize!
+  end
+
+  # GET /error_templates/1
+  # GET /error_templates/1.json
+  def show
+    authorize!
+  end
+
+  # GET /error_templates/new
+  def new
+    @error_template = ErrorTemplate.new
+    authorize!
+  end
+
+  # GET /error_templates/1/edit
+  def edit
+    authorize!
+  end
+
+  # POST /error_templates
+  # POST /error_templates.json
+  def create
+    @error_template = ErrorTemplate.new(error_template_params)
+    authorize!
+
+    respond_to do |format|
+      if @error_template.save
+        format.html { redirect_to @error_template, notice: 'Error template was successfully created.' }
+        format.json { render :show, status: :created, location: @error_template }
+      else
+        format.html { render :new }
+        format.json { render json: @error_template.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /error_templates/1
+  # PATCH/PUT /error_templates/1.json
+  def update
+    authorize!
+    respond_to do |format|
+      if @error_template.update(error_template_params)
+        format.html { redirect_to @error_template, notice: 'Error template was successfully updated.' }
+        format.json { render :show, status: :ok, location: @error_template }
+      else
+        format.html { render :edit }
+        format.json { render json: @error_template.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /error_templates/1
+  # DELETE /error_templates/1.json
+  def destroy
+    authorize!
+    @error_template.destroy
+    respond_to do |format|
+      format.html { redirect_to error_templates_url, notice: 'Error template was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  def add_attribute
+    authorize!
+    @error_template.error_template_attributes << ErrorTemplateAttribute.find(params['error_template_attribute_id'])
+    respond_to do |format|
+      format.html { redirect_to @error_template }
+      format.json { head :no_content }
+    end
+  end
+
+  def remove_attribute
+    authorize!
+    @error_template.error_template_attributes.delete(ErrorTemplateAttribute.find(params['error_template_attribute_id']))
+    respond_to do |format|
+      format.html { redirect_to @error_template }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_error_template
+      @error_template = ErrorTemplate.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def error_template_params
+      params[:error_template].permit(:name, :execution_environment_id, :signature, :description, :hint)
+    end
+end

app/controllers/exercise_collections_controller.rb

@@ -0,0 +1,51 @@
+class ExerciseCollectionsController < ApplicationController
+  include CommonBehavior
+
+  before_action :set_exercise_collection, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @exercise_collections = ExerciseCollection.all.paginate(:page => params[:page])
+    authorize!
+  end
+
+  def show
+  end
+
+  def new
+    @exercise_collection = ExerciseCollection.new
+    authorize!
+  end
+
+  def create
+    @exercise_collection = ExerciseCollection.new(exercise_collection_params)
+    authorize!
+    create_and_respond(object: @exercise_collection)
+  end
+
+  def destroy
+    authorize!
+    destroy_and_respond(object: @exercise_collection)
+  end
+
+  def edit
+  end
+
+  def update
+    update_and_respond(object: @exercise_collection, params: exercise_collection_params)
+  end
+
+  private
+
+  def set_exercise_collection
+    @exercise_collection = ExerciseCollection.find(params[:id])
+    authorize!
+  end
+
+  def authorize!
+    authorize(@exercise_collection || @exercise_collections)
+  end
+
+  def exercise_collection_params
+    params[:exercise_collection].permit(:name, :exercise_ids => [])
+  end
+end

app/controllers/exercises_controller.rb

@@ -6,7 +6,7 @@ class ExercisesController < ApplicationController
 
   before_action :handle_file_uploads, only: [:create, :update]
   before_action :set_execution_environments, only: [:create, :edit, :new, :update]
-  before_action :set_exercise, only: MEMBER_ACTIONS + [:clone, :implement, :working_times, :intervention, :search, :run, :statistics, :submit, :reload]
+  before_action :set_exercise, only: MEMBER_ACTIONS + [:clone, :implement, :working_times, :intervention, :search, :run, :statistics, :submit, :reload, :feedback]
   before_action :set_external_user, only: [:statistics]
   before_action :set_file_types, only: [:create, :edit, :new, :update]
   before_action :set_course_token, only: [:implement]
@@ -28,7 +28,6 @@ class ExercisesController < ApplicationController
     1
   end
 
-
   def java_course_token
     "702cbd2a-c84c-4b37-923a-692d7d1532d0"
   end
@@ -94,6 +93,11 @@ class ExercisesController < ApplicationController
     collect_set_and_unset_exercise_tags
   end
 
+  def feedback
+    authorize!
+    @feedbacks = @exercise.user_exercise_feedbacks.paginate(page: params[:page])
+  end
+
   def import_proforma_xml
     begin
       user = user_for_oauth2_request()
@@ -147,8 +151,7 @@ class ExercisesController < ApplicationController
   private :user_by_code_harbor_token
 
   def exercise_params
-    params[:exercise][:expected_worktime_seconds] = params[:exercise][:expected_worktime_minutes].to_i * 60
-    params[:exercise].permit(:description, :execution_environment_id, :file_id, :instructions, :public, :hide_file_tree, :allow_file_creation, :allow_auto_completion, :title, :expected_difficulty, :expected_worktime_seconds, files_attributes: file_attributes, :tag_ids => []).merge(user_id: current_user.id, user_type: current_user.class.name)
+    params[:exercise].permit(:description, :execution_environment_id, :file_id, :instructions, :public, :hide_file_tree, :allow_file_creation, :allow_auto_completion, :title, :expected_difficulty, files_attributes: file_attributes, :tag_ids => []).merge(user_id: current_user.id, user_type: current_user.class.name)
   end
   private :exercise_params
 
@@ -388,10 +391,13 @@ class ExercisesController < ApplicationController
       # otherwise an internal user could be shown a false rfc here, since current_user.id is polymorphic, but only makes sense for external users when used with rfcs.)
       # redirect 10 percent pseudorandomly to the feedback page
       if current_user.respond_to? :external_id
-        if ((current_user.id + @submission.exercise.created_at.to_i) % 10 == 1)
+        if @submission.redirect_to_feedback?
           redirect_to_user_feedback
           return
-        elsif rfc = RequestForComment.unsolved.where(exercise_id: @submission.exercise, user_id: current_user.id).first
+        end
+
+        rfc = @submission.own_unsolved_rfc
+        if rfc
           # set a message that informs the user that his own RFC should be closed.
           flash[:notice] = I18n.t('exercises.submit.full_score_redirect_to_own_rfc')
           flash.keep(:notice)
@@ -401,24 +407,30 @@ class ExercisesController < ApplicationController
             format.json { render(json: {redirect: url_for(rfc)}) }
           end
           return
+        end
 
         # else: show open rfc for same exercise if available
-        elsif rfc = RequestForComment.unsolved.where(exercise_id: @submission.exercise).where.not(question: nil).order("RANDOM()").find { | rfc_element |(rfc_element.comments_count < 5) }
+        rfc = @submission.unsolved_rfc
+        unless rfc.nil?
           # set a message that informs the user that his score was perfect and help in RFC is greatly appreciated.
           flash[:notice] = I18n.t('exercises.submit.full_score_redirect_to_rfc')
           flash.keep(:notice)
 
           respond_to do |format|
-            format.html { redirect_to(rfc) }
-            format.json { render(json: {redirect: url_for(rfc)}) }
+            format.html {redirect_to(rfc)}
+            format.json {render(json: {redirect: url_for(rfc)})}
           end
           return
         end
       end
     else
       # redirect to feedback page if score is less than 100 percent
-       redirect_to_user_feedback
-      return
+       if @exercise.needs_more_feedback?
+         redirect_to_user_feedback
+       else
+         redirect_to_lti_return_path
+       end
+       return
     end
     redirect_to_lti_return_path
   end

app/controllers/submissions_controller.rb

@@ -6,7 +6,7 @@ class SubmissionsController < ApplicationController
   include SubmissionScoring
   include Tubesock::Hijack
 
-  before_action :set_submission, only: [:download, :download_file, :render_file, :run, :score, :show, :statistics, :stop, :test]
+  before_action :set_submission, only: [:download, :download_file, :render_file, :run, :score, :extract_errors, :show, :statistics, :stop, :test]
   before_action :set_docker_client, only: [:run, :test]
   before_action :set_files, only: [:download, :download_file, :render_file, :show]
   before_action :set_file, only: [:download_file, :render_file]
@@ -191,6 +191,9 @@ class SubmissionsController < ApplicationController
   end
 
   def kill_socket(tubesock)
+    # search for errors and save them as StructuredError (for scoring runs see submission_scoring.rb)
+    extract_errors
+
     # save the output of this "run" as a "testrun" (scoring runs are saved in submission_scoring.rb)
     save_run_output
 
@@ -199,6 +202,17 @@ class SubmissionsController < ApplicationController
     tubesock.close
   end
 
+  def extract_errors
+    if !@message_buffer.blank?
+      @submission.exercise.execution_environment.error_templates.each do |template|
+        pattern = Regexp.new(template.signature).freeze
+        if pattern.match(@message_buffer)
+          StructuredError.create_from_template(template, @message_buffer)
+        end
+      end
+    end
+  end
+
   def handle_message(message, tubesock, container)
     @run_output ||= ""
     # Handle special commands first

app/controllers/user_exercise_feedbacks_controller.rb

@@ -2,6 +2,7 @@ class UserExerciseFeedbacksController < ApplicationController
   include CommonBehavior
 
   before_action :set_user_exercise_feedback, only: [:edit, :update]
+  before_action :set_user_exercise_feedback_by_id, only: [:show, :destroy]
 
   def comment_presets
     [[0,t('user_exercise_feedback.difficulty_easy')],
@@ -19,10 +20,15 @@ class UserExerciseFeedbacksController < ApplicationController
      [4,t('user_exercise_feedback.estimated_time_more_30')]]
   end
 
-  def authorize!
-    authorize(@uef)
+  def index
+    @search = UserExerciseFeedback.all.search params[:q]
+    @uefs = @search.result.includes(:execution_environment).order(:id).paginate(page: params[:page])
+    authorize!
+  end
+
+  def show
+    authorize!
   end
-  private :authorize!
 
   def create
     @exercise = Exercise.find(uef_params[:exercise_id])
@@ -49,7 +55,8 @@ class UserExerciseFeedbacksController < ApplicationController
   end
 
   def destroy
-    destroy_and_respond(object: @tag)
+    authorize!
+    destroy_and_respond(object: @uef)
   end
 
   def edit
@@ -58,11 +65,6 @@ class UserExerciseFeedbacksController < ApplicationController
     authorize!
   end
 
-  def uef_params
-    params[:user_exercise_feedback].permit(:feedback_text, :difficulty, :exercise_id, :user_estimated_worktime).merge(user_id: current_user.id, user_type: current_user.class.name)
-  end
-  private :uef_params
-
   def new
     @texts = comment_presets.to_a
     @times = time_presets.to_a
@@ -89,6 +91,12 @@ class UserExerciseFeedbacksController < ApplicationController
     end
   end
 
+  private
+
+  def authorize!
+    authorize(@uef || @uefs)
+  end
+
   def to_s
     name
   end
@@ -98,6 +106,14 @@ class UserExerciseFeedbacksController < ApplicationController
     @uef = UserExerciseFeedback.find_by(exercise_id: params[:user_exercise_feedback][:exercise_id], user: current_user)
   end
 
+  def set_user_exercise_feedback_by_id
+    @uef = UserExerciseFeedback.find(params[:id])
+  end
+
+  def uef_params
+    params[:user_exercise_feedback].permit(:feedback_text, :difficulty, :exercise_id, :user_estimated_worktime).merge(user_id: current_user.id, user_type: current_user.class.name)
+  end
+
   def validate_inputs(uef_params)
     begin
       if uef_params[:difficulty].to_i < 0 || uef_params[:difficulty].to_i >= comment_presets.size
@@ -112,4 +128,4 @@ class UserExerciseFeedbacksController < ApplicationController
     end
   end
 
-end
+end