cafe-grader-web Commit - r214:cdf8c2c3dce8

cafe-grader-web

Commit `r214:cdf8c2c3dce8` public

parent | child

Description:

added solution submission with grading

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r214:cdf8c2c3dce8 - Mon, 18 Jan 2010 23:36:23 - 3 files changed: 53 inserted, 8 deleted

app/controllers/main_controller.rb ¶ +36 -4

               class MainController < ApplicationController
                 SYSTEM_MODE_CONF_KEY = 'system.mode'
                 before_filter :authenticate, :except => [:index, :login]
                 before_filter :check_viewability, :except => [:index, :login]
                 # COMMENTED OUT: filter in each action instead
                 # before_filter :verify_time_limit, :only => [:submit]
-            -   verify :method => :post, :only => [:submit],
+            +   verify :method => :post, :only => [:submit, :new_input, :download_input, :submit_solution],
                        :redirect_to => { :action => :index }
                 # COMMENT OUT: only need when having high load
                 # caches_action :index, :login
                 # NOTE: This method is not actually needed, 'config/routes.rb' has
                 # assigned action login as a default action.
                 def index
                   redirect_to :action => 'login'
                 end
                 def login
                   saved_notice = flash[:notice]
                   reset_session
                   flash[:notice] = saved_notice
                   # EXPERIMENT:
                   # Hide login if in single user mode and the url does not
                   # explicitly specify /login
                   #
                   # logger.info "PATH: #{request.path}"
                   # if Configuration['system.single_user_mode'] and
                   #     request.path!='/main/login'
                   #   @hidelogin = true
                   # end
                   @announcements = Announcement.find_for_frontpage
                   render :action => 'login', :layout => 'empty'
                 end
                 def list
                   prepare_list_information
                 end
                 def help
                   @user = User.find(session[:user_id])
                 end
                 def submit
                   user = User.find(session[:user_id])
                   @submission = Submission.new(params[:submission])
                   @submission.user = user
                   @submission.language_id = 0
                   if (params['file']) and (params['file']!='')
                     @submission.source = params['file'].read
                     @submission.source_filename = params['file'].original_filename
                   end
                   @submission.submitted_at = Time.new.gmtime
                   if Configuration[SYSTEM_MODE_CONF_KEY]=='contest' and
                       user.site!=nil and user.site.finished?
                     @submission.errors.add_to_base "The contest is over."
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   if @submission.valid?
                     if @submission.save == false
               	flash[:notice] = 'Error saving your submission'
                     elsif Task.create(:submission_id => @submission.id,
                                       :status => Task::STATUS_INQUEUE) == false
               	flash[:notice] = 'Error adding your submission to task queue'
                     end
                   else
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   redirect_to :action => 'list'
                 end
                 def source
                   submission = Submission.find(params[:id])
                   if submission.user_id == session[:user_id]
                     send_data(submission.source,
               		{:filename => submission.download_filename,
                                 :type => 'text/plain'})
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def compiler_msg
                   @submission = Submission.find(params[:id])
                   if @submission.user_id == session[:user_id]
                     render :action => 'compiler_msg', :layout => 'empty'
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def submission
                   @user = User.find(session[:user_id])
                   @problems = Problem.find_available_problems
                   if params[:id]==nil
                     @problem = nil
                     @submissions = nil
                   else
                     @problem = Problem.find_by_name(params[:id])
                     if not @problem.available
                       redirect_to :action => 'list'
                       flash[:notice] = 'Error: submissions for that problem are not viewable.'
                       return
                     end
                     @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id)
                   end
                 end
                 def result
                   if !Configuration.show_grading_result
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   prepare_grading_result(@submission)
                 end
                 def load_output
                   if !Configuration.show_grading_result or params[:num]==nil
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   case_num = params[:num].to_i
                   out_filename = output_filename(@user.login,
                                                  @submission.problem.name,
                                                  @submission.id,
                                                  case_num)
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   response.headers['Content-Type'] = "application/force-download"
                   response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
                   response.headers["X-Sendfile"] = out_filename
                   response.headers['Content-length'] = File.size(out_filename)
                   render :nothing => true
                 end
                 def error
                   @user = User.find(session[:user_id])
                 end
                 # announcement refreshing and hiding methods
                 def announcements
                   if params.has_key? 'recent'
                     prepare_announcements(params[:recent])
                   else
                     prepare_announcements
                   end
                   render(:partial => 'announcement',
                          :collection => @announcements,
                          :locals => {:announcement_effect => true})
                 end
                 # actions for Code Jom
                 def new_input
                   problem = Problem.find(params[:id])
                   user = User.find(session[:user_id])
                   if user.can_request_new_test_pair_for? problem
                     assignment = user.get_new_test_pair_assignment_for problem
                     assignment.save
                     send_data(assignment.test_pair.input,
                               { :filename => "#{problem.name}-#{assignment.request_number}.in",
                                 :type => 'text/plain' })
-            -     else
+            +     else
                     flash[:notice] = 'You cannot request new input now.'
                     redirect_to :action => 'list'
                   end
                 end
-            -   def download
+            +   def download_input
                   problem = Problem.find(params[:id])
                   user = User.find(session[:user_id])
                   recent_assignment = user.get_recent_test_pair_assignment_for problem
                   if recent_assignment != nil
                     send_data(recent_assignment.test_pair.input,
                               { :filename => "#{problem.name}-#{recent_assignment.request_number}.in",
                                 :type => 'text/plain' })
                   else
-            -       flash[:notice] = 'You have not request for any input data for this problem.'
+            +       flash[:notice] = 'You have not requested for any input data for this problem.'
+            +       redirect_to :action => 'list'
+            +     end
+            +   end
+            +
+            +   def submit_solution
+            +     problem = Problem.find(params[:id])
+            +     user = User.find(session[:user_id])
+            +     recent_assignment = user.get_recent_test_pair_assignment_for problem
+            +     if recent_assignment != nil
+            +       submitted_solution = params[:file].read
+            +       test_pair = recent_assignment.test_pair
+            +       passed = test_pair.grade(submitted_solution)
+            +       points = passed ? 100 : 0
+            +       submission = Submission.new(:user => user,
+            +                                   :problem => problem,
+            +                                   :source => params[:file].read,
+            +                                   :source_filename => params['file'].original_filename,
+            +                                   :language_id => 0,
+            +                                   :submitted_at => Time.new.gmtime,
+            +                                   :graded_at => Time.new.gmtime,
+            +                                   :points => points)
+            +       submission.save
+            +       recent_assignment.submitted = true
+            +       recent_assignment.save
+            +       if passed
+            +         flash[:notice] = 'Correct solution'
+            +       else
+            +         flash[:notice] = 'Incorrect solution'
+            +       end
+            +       redirect_to :action => 'list'
+            +     else
+            +       flash[:notice] = 'You have not requested for any input data for this problem.'
                     redirect_to :action => 'list'
                   end
                 end
                 protected
                 def prepare_announcements(recent=nil)
                   if Configuration.show_tasks_to?(@user)
                     @announcements = Announcement.find_published(true)
                   else
                     @announcements = Announcement.find_published
                   end
                   if recent!=nil
                     recent_id = recent.to_i
                     @announcements = @announcements.find_all { |a| a.id > recent_id }
                   end
                 end
                 def prepare_list_information
                   @problems = Problem.find_available_problems
                   @prob_submissions = Array.new
                   @user = User.find(session[:user_id])
                   @problems.each do |p|
                     sub = Submission.find_last_by_user_and_problem(@user.id,p.id)
                     if sub!=nil
                       @prob_submissions << { :count => sub.number, :submission => sub }
                     else
                       @prob_submissions << { :count => 0, :submission => nil }
                     end
                   end
                   prepare_announcements
                 end
                 def check_viewability
                   @user = User.find(session[:user_id])
                   if (!Configuration.show_tasks_to?(@user)) and
                       ((action_name=='submission') or (action_name=='submit'))
                     redirect_to :action => 'list' and return
                   end
                 end
                 def prepare_grading_result(submission)
                   if Configuration.task_grading_info.has_key? submission.problem.name
                     grading_info = Configuration.task_grading_info[submission.problem.name]
                   else
                     # guess task info from problem.full_score
                     cases = submission.problem.full_score / 10
                     grading_info = {
                       'testruns' => cases,
                       'testcases' => cases
                     }
                   end
                   @test_runs = []
                   if grading_info['testruns'].is_a? Integer
                     trun_count = grading_info['testruns']
                     trun_count.times do |i|
                       @test_runs << [ read_grading_result(@user.login,
                                                           submission.problem.name,
                                                           submission.id,
                                                           i+1) ]
                     end
                   else
                     grading_info['testruns'].keys.sort.each do |num|
                       run = []
                       testrun = grading_info['testruns'][num]
                       testrun.each do |c|
                         run << read_grading_result(@user.login,
                                                    submission.problem.name,
                                                    submission.id,
                                                    c)
                       end
                       @test_runs << run
                     end
                   end
                 end
                 def grading_result_dir(user_name, problem_name, submission_id, case_num)
                   return "#{GRADING_RESULT_DIR}/#{user_name}/#{problem_name}/#{submission_id}/test-result/#{case_num}"
                 end
                 def output_filename(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   return "#{dir}/output.txt"
                 end
                 def read_grading_result(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   result_file_name = "#{dir}/result"
                   if !FileTest.exists?(result_file_name)
                     return {:num => case_num, :msg => 'program did not run'}
                   else
                     results = File.open(result_file_name).readlines
                     run_stat = extract_running_stat(results)
                     output_filename = "#{dir}/output.txt"
                     if FileTest.exists?(output_filename)
                       output_file = true

app/models/test_pair.rb ¶ +13

               # TestPair stores an input-solution pair for a problem.  This is used
               # in a certain "test-pair"-type problem for the CodeJom competition
               # which follows the Google Code Jam format, i.e., a participant only
               # submits a solution to a single random input that the participant
               # requested.  This input-solution pair is a TestPair.
               class TestPair < ActiveRecord::Base
                 belongs_to :problem
+            +
+            +   def grade(submitted_solution)
+            +     sols = solution.split
+            +     subs = submitted_solution.split
+            +     if sols.length == subs.length
+            +       subs.length.times do |i|
+            +         return false if subs[i]!=sols[i]
+            +       end
+            +       return true
+            +     else
+            +       return false
+            +     end
+            +   end
               end

app/views/main/_problem.html.erb ¶ +4 -4

               <tr class="info-<%= (problem_counter%2==0) ? "even" : "odd" %>">
                 <td>
                   <%= "#{problem_counter+1}" %>
                 </td>
                 <td>
                   <%= "#{problem.full_name} (#{problem.name})" %>
                   <%= link_to "[#{t 'main.problem_desc'}]", problem.url, :popup => true if (problem.url!=nil) and (problem.url!='') %>
                 </td>
                 <td align="center">
                   <%= @prob_submissions[problem_counter][:count] %>
                 </td>
                 <td>
                   <span id="problem-form-<%= problem.id %>">
-            -       <% form_tag "new_input/#{problem.id}", :method => :post do -%>
+            +       <% form_tag({:action => 'new_input', :id => problem.id}, :method => :post) do -%>
               	<input type="submit" value="New input"/>
                     <% end -%>
-            -       <% form_tag "download/#{problem.id}", :method => :post do -%>
+            +       <% form_tag({ :action => 'download_input', :id => problem.id }, :method => :post) do -%>
                       <input type="submit" value="Download input"/>
                     <% end -%>
-            -       <% form_tag "submit_solution/#{problem.id}", :method => :post do -%>
-            - 	<input type="file">
+            +       <% form_tag({ :action => 'submit_solution', :id => problem.id }, :method => :post, :multipart => true) do -%>
+            + 	<input type="file" name="file">
               	<input type="submit" value="Submit solution"/>
                     <% end -%>
                   </span>
                 </td>
               </tr>

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r214:cdf8c2c3dce8 - Mon, 18 Jan 2010 23:36:23 - 3 files changed: 53 inserted, 8 deleted

Sign in to your account

Commit r214:cdf8c2c3dce8 public

Author

r214:cdf8c2c3dce8 - Mon, 18 Jan 2010 23:36:23 - 3 files changed: 53 inserted, 8 deleted

Commit `r214:cdf8c2c3dce8` public