cafe-grader-web Commit - r213:805be1d05f2d

cafe-grader-web

Commit `r213:805be1d05f2d` public

parent | child

Description:

added test pair assignment, requests new input, downloads input

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

r213:805be1d05f2d - Mon, 18 Jan 2010 23:25:53 - 13 files changed: 178 inserted, 5 deleted

app/models/test_pair_assignment.rb created 644 ¶ +5

@@ -0,0 +1,5
	1	+ class TestPairAssignment < ActiveRecord::Base
	2	+ belongs_to :user
	3	+ belongs_to :test_pair
	4	+ belongs_to :problem
	5	+ end

db/migrate/20100118160800_add_number_to_test_pair.rb created 644 ¶ +9

@@ -0,0 +1,9
	1	+ class AddNumberToTestPair < ActiveRecord::Migration
	2	+ def self.up
	3	+ add_column 'test_pairs', 'number', :integer
	4	+ end
	5	+
	6	+ def self.down
	7	+ remove_column 'test_pairs', 'number'
	8	+ end
	9	+ end

db/migrate/20100118162000_create_test_pair_assignments.rb created 644 ¶ +16

@@ -0,0 +1,16
	1	+ class CreateTestPairAssignments < ActiveRecord::Migration
	2	+ def self.up
	3	+ create_table :test_pair_assignments do \|t\|
	4	+ t.integer "user_id"
	5	+ t.integer "problem_id"
	6	+ t.integer "test_pair_id"
	7	+ t.integer "test_pair_number"
	8	+ t.integer "request_number"
	9	+ t.timestamps
	10	+ end
	11	+ end
	12	+
	13	+ def self.down
	14	+ drop_table :test_pair_assignments
	15	+ end
	16	+ end

db/migrate/20100118174404_add_submitted_to_test_pair_assignment.rb created 644 ¶ +9

@@ -0,0 +1,9
	1	+ class AddSubmittedToTestPairAssignment < ActiveRecord::Migration
	2	+ def self.up
	3	+ add_column 'test_pair_assignments', 'submitted', :boolean
	4	+ end
	5	+
	6	+ def self.down
	7	+ remove_column 'test_pair_assignments', 'submitted'
	8	+ end
	9	+ end

test/fixtures/test_pair_assignments.yml created 644 ¶ +7

@@ -0,0 +1,7
	1	+ # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
	2	+
	3	+ # one:
	4	+ # column: value
	5	+ #
	6	+ # two:
	7	+ # column: value

test/unit/test_pair_assignment_test.rb created 644 ¶ +8

@@ -0,0 +1,8
	1	+ require 'test_helper'
	2	+
	3	+ class TestPairAssignmentTest < ActiveSupport::TestCase
	4	+ # Replace this with your real tests.
	5	+ test "the truth" do
	6	+ assert true
	7	+ end
	8	+ end

app/controllers/main_controller.rb ¶ +31

                 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
+            +       flash[:notice] = 'You cannot request new input now.'
+            +       redirect_to :action => 'list'
+            +     end
+            +   end
+            +
+            +   def download
+            +     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.'
+            +       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
                       output_size = File.size(output_filename)
                     else
                       output_file = false
                       output_size = 0

app/models/problem.rb ¶ +15

               class Problem < ActiveRecord::Base
                 belongs_to :description
                 has_many :test_pairs, :dependent => :delete_all
                 validates_presence_of :name
                 validates_format_of :name, :with => /^\w+$/
                 validates_presence_of :full_name
                 DEFAULT_TIME_LIMIT = 1
                 DEFAULT_MEMORY_LIMIT = 32
+            +   def test_pair_count
+            +     @test_pair_count ||= test_pairs.size
+            +   end
+            +
+            +   def uses_random_test_pair?
+            +     test_pair_count != 0
+            +   end
+            +
+            +   def random_test_pair(forbidden_numbers=nil)
+            +     begin
+            +       test_num = 1 + rand(test_pair_count)
+            +     end while forbidden_numbers!=nil and forbidden_numbers.include? test_num
+            +     test_pairs.find_by_number test_num
+            +   end
+            +
                 def self.find_available_problems
                   find(:all, :conditions => {:available => true}, :order => "date_added DESC")
                 end
                 def self.create_from_import_form_params(params, old_problem=nil)
                   problem = old_problem || Problem.new
                   import_params = Problem.extract_params_and_check(params, problem)
                   if not problem.valid?
                     return problem, 'Error importing'
                   end
                   problem.full_score = 100
                   problem.date_added = Time.new
                   problem.test_allowed = true
                   problem.output_only = false
                   problem.available = false
                   if not problem.save
                     return problem, 'Error importing'
                   end
                   import_to_db = params.has_key? :import_to_db
                   importer = TestdataImporter.new(problem)
                   if not importer.import_from_file(import_params[:file],
                                                    import_params[:time_limit],
                                                    import_params[:memory_limit],
                                                    import_to_db)
                     problem.errors.add_to_base('Import error.')
                   end
                   return problem, importer.log_msg
                 end
                 protected
                 def self.to_i_or_default(st, default)
                   if st!=''
                     st.to_i
                   else
                     default
                   end
                 end
                 def self.extract_params_and_check(params, problem)
                   time_limit = Problem.to_i_or_default(params[:time_limit],
                                                        DEFAULT_TIME_LIMIT)
                   memory_limit = Problem.to_i_or_default(params[:memory_limit],
                                                          DEFAULT_MEMORY_LIMIT)
                   if time_limit==0 and time_limit_s!='0'
                     problem.errors.add_to_base('Time limit format errors.')
                   elsif time_limit<=0 or time_limit >60
                     problem.errors.add_to_base('Time limit out of range.')
                   end
                   if memory_limit==0 and memory_limit_s!='0'
                     problem.errors.add_to_base('Memory limit format errors.')
                   elsif memory_limit<=0 or memory_limit >512
                     problem.errors.add_to_base('Memory limit out of range.')
                   end
                   if params[:file]==nil or params[:file]==''
                     problem.errors.add_to_base('No testdata file.')
                   end
                   file = params[:file]
                   if problem.errors.length!=0
                     return problem
                   end
                   problem.name = params[:name]
                   if params[:full_name]!=''
                     problem.full_name = params[:full_name]
                   else
                     problem.full_name = params[:name]
                   end
                   return {
                     :time_limit => time_limit,
                     :memory_limit => memory_limit,
                     :file => file
                   }
                 end
               end

app/models/test_pair.rb ¶ +6

@@ -1,3 +1,9
		1	+ # TestPair stores an input-solution pair for a problem. This is used
		2	+ # in a certain "test-pair"-type problem for the CodeJom competition
		3	+ # which follows the Google Code Jam format, i.e., a participant only
		4	+ # submits a solution to a single random input that the participant
		5	+ # requested. This input-solution pair is a TestPair.
		6	+
1	class TestPair < ActiveRecord::Base	7	class TestPair < ActiveRecord::Base
2	belongs_to :problem	8	belongs_to :problem
3	end	9	end

app/models/user.rb ¶ +44

               require 'digest/sha1'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
                 has_many :test_requests, :order => "submitted_at DESC"
                 has_many :messages,
                          :class_name => "Message",
                          :foreign_key => "sender_id",
                          :order => 'created_at DESC'
                 has_many :replied_messages,
                          :class_name => "Message",
                          :foreign_key => "receiver_id",
                          :order => 'created_at DESC'
+            +   has_many :test_pair_assignments, :dependent => :delete_all
+            +
                 belongs_to :site
                 belongs_to :country
                 named_scope :activated_users, :conditions => {:activated => true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /^[\_A-Za-z0-9]+$/
                 validates_length_of :login, :within => 3..30
                 validates_presence_of :full_name
                 validates_length_of :full_name, :minimum => 1
                 validates_presence_of :password, :if => :password_required?
                 validates_length_of :password, :within => 4..20, :if => :password_required?
                 validates_confirmation_of :password, :if => :password_required?
                 validates_format_of :email,
                                     :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i,
                                     :if => :email_validation?
                 validate :uniqueness_of_email_from_activated_users,
                          :if => :email_validation?
                 validate :enough_time_interval_between_same_email_registrations,
                          :if => :email_validation?
                 # these are for ytopc
                 # disable for now
                 #validates_presence_of :province
                 attr_accessor :password
                 before_save :encrypt_new_password
                 before_save :assign_default_site
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   return user if user && user.authenticated?(password)
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def admin?
                   self.roles.detect {|r| r.name == 'admin' }
                 end
+            +   # These are methods related to test pairs
+            +
+            +   def get_test_pair_assignments_for(problem)
+            +     test_pair_assignments.find_all { |a| a.problem_id == problem.id }
+            +   end
+            +
+            +   def get_recent_test_pair_assignment_for(problem)
+            +     assignments = get_test_pair_assignments_for problem
+            +     if assignments.length == 0
+            +       return nil
+            +     else
+            +       recent = assignments[0]
+            +       assignments.each do |a|
+            +         recent = a if a.request_number > recent.request_number
+            +       end
+            +       return recent
+            +     end
+            +   end
+            +
+            +   def can_request_new_test_pair_for?(problem)
+            +     recent = get_recent_test_pair_assignment_for problem
+            +     return (recent == nil or recent.submitted)
+            +   end
+            +
+            +   def get_new_test_pair_assignment_for(problem)
+            +     previous_assignment_numbers =
+            +       get_test_pair_assignments_for(problem).collect {|a| a.test_pair_number }
+            +     test_pair = problem.random_test_pair(previous_assignment_numbers)
+            +     if test_pair
+            +       assignment = TestPairAssignment.new(:user => self,
+            +                                           :problem => problem,
+            +                                           :test_pair => test_pair,
+            +                                           :test_pair_number => test_pair.number,
+            +                                           :request_number =>
+            +                                           previous_assignment_numbers.length + 1,
+            +                                           :submitted => false)
+            +       return assignment
+            +     else
+            +       return nil
+            +     end
+            +   end
+            +
                 def email_for_editing
                   if self.email==nil
                     "(unknown)"
                   elsif self.email==''
                     "(blank)"
                   else
                     self.email
                   end
                 end
                 def email_for_editing=(e)
                   self.email=e
                 end
                 def alias_for_editing
                   if self.alias==nil
                     "(unknown)"
                   elsif self.alias==''
                     "(blank)"
                   else
                     self.alias
                   end
                 end
                 def alias_for_editing=(e)
                   self.alias=e
                 end
                 def activation_key
                   if self.hashed_password==nil
                     encrypt_new_password
                   end
                   Digest::SHA1.hexdigest(self.hashed_password)[0..7]
                 end
                 def verify_activation_key(key)
                   key == activation_key
                 end
                 def self.random_password(length=5)
                   chars = 'abcdefghjkmnopqrstuvwxyz'
                   password = ''
                   length.times { password << chars[rand(chars.length - 1)] }
                   password
                 end
                 def self.find_non_admin_with_prefix(prefix='')
                   users = User.find(:all)
                   return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
                 end
                 protected
                   def encrypt_new_password
                     return if password.blank?
                     self.salt = (10+rand(90)).to_s
                     self.hashed_password = User.encrypt(self.password,self.salt)
                   end
                   def assign_default_site
                     # have to catch error when migrating (because self.site is not available).
                     begin
                       if self.site==nil
                         self.site = Site.find_by_name('default')
                         if self.site==nil
                           self.site = Site.find(1)  # when 'default has be renamed'
                         end
                       end
                     rescue
                     end
                   end
                   def password_required?
                     self.hashed_password.blank? || !self.password.blank?
                   end
                   def self.encrypt(string,salt)
                     Digest::SHA1.hexdigest(salt + string)
                   end
                   def uniqueness_of_email_from_activated_users
                     user = User.activated_users.find_by_email(self.email)
                     if user and (user.login != self.login)
                       self.errors.add_to_base("Email has already been taken")
                     end
                   end
                   def enough_time_interval_between_same_email_registrations
                     return if !self.new_record?
                     return if self.activated
                     open_user = User.find_by_email(self.email,
                                                    :order => 'created_at DESC')
                     if open_user and open_user.created_at and
                         (open_user.created_at > Time.now.gmtime - 5.minutes)
                       self.errors.add_to_base("There are already unactivated registrations with this e-mail address (please wait for 5 minutes)")
                     end
                   end

app/views/main/_problem.html.erb ¶ +12 -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>
-            -     <%= render :partial => 'submission_short',
+            +     <span id="problem-form-<%= problem.id %>">
-            -                :locals => {
+            +       <% form_tag "new_input/#{problem.id}", :method => :post do -%>
-            -                  :submission => @prob_submissions[problem_counter][:submission],
+            + 	<input type="submit" value="New input"/>
-            -                  :problem_name => problem.name }%>
+            +       <% end -%>
+            +       <% form_tag "download/#{problem.id}", :method => :post do -%>
+            +         <input type="submit" value="Download input"/>
+            +       <% end -%>
+            +       <% form_tag "submit_solution/#{problem.id}", :method => :post do -%>
+            + 	<input type="file">
+            + 	<input type="submit" value="Submit solution"/>
+            +       <% end -%>
+            +     </span>
                 </td>
               </tr>

db/schema.rb ¶ +13 -1

               # This file is auto-generated from the current state of the database. Instead of editing this file,
               # please use the migrations feature of Active Record to incrementally modify your database, and
               # then regenerate this schema definition.
               #
               # Note that this schema.rb definition is the authoritative source for your database schema. If you need
               # to create the application database on another system, you should be using db:schema:load, not running
               # all the migrations from scratch. The latter is a flawed and unsustainable approach (the more migrations
               # you'll amass, the slower it'll run and the greater likelihood for issues).
               #
               # It's strongly recommended to check this file into your version control system.
-            - ActiveRecord::Schema.define(:version => 20100113094740) do
+            + ActiveRecord::Schema.define(:version => 20100118174404) do
                 create_table "announcements", :force => true do |t|
                   t.string   "author"
                   t.text     "body"
                   t.boolean  "published"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.boolean  "frontpage",    :default => false
                   t.boolean  "contest_only", :default => false
                   t.string   "title"
                 end
                 create_table "configurations", :force => true do |t|
                   t.string   "key"
                   t.string   "value_type"
                   t.string   "value"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "countries", :force => true do |t|
                   t.string   "name"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "descriptions", :force => true do |t|
                   t.text     "body"
                   t.boolean  "markdowned"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "grader_processes", :force => true do |t|
                   t.string   "host",       :limit => 20
                   t.integer  "pid"
                   t.string   "mode"
                   t.boolean  "active"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.integer  "task_id"
                   t.string   "task_type"
                   t.boolean  "terminated"
                 end
                 add_index "grader_processes", ["host", "pid"], :name => "index_grader_processes_on_ip_and_pid"
                 create_table "languages", :force => true do |t|
                   t.string "name",        :limit => 10
                   t.string "pretty_name"
                   t.string "ext",         :limit => 10
                   t.string "common_ext"
                 end
                 create_table "messages", :force => true do |t|
                   t.integer  "sender_id"
                   t.integer  "receiver_id"
                   t.integer  "replying_message_id"
                   t.text     "body"
                   t.boolean  "replied"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 create_table "problems", :force => true do |t|
                   t.string  "name",           :limit => 30
                   t.string  "full_name"
                   t.integer "full_score"
                   t.date    "date_added"
                   t.boolean "available"
                   t.string  "url"
                   t.integer "description_id"
                   t.boolean "test_allowed"
                   t.boolean "output_only"
                 end
                 create_table "rights", :force => true do |t|
                   t.string "name"
                   t.string "controller"
                   t.string "action"
                 end
                 create_table "rights_roles", :id => false, :force => true do |t|
                   t.integer "right_id"
                   t.integer "role_id"
                 end
                 add_index "rights_roles", ["role_id"], :name => "index_rights_roles_on_role_id"
                 create_table "roles", :force => true do |t|
                   t.string "name"
                 end
                 create_table "roles_users", :id => false, :force => true do |t|
                   t.integer "role_id"
                   t.integer "user_id"
                 end
                 add_index "roles_users", ["user_id"], :name => "index_roles_users_on_user_id"
                 create_table "sessions", :force => true do |t|
                   t.string   "session_id"
                   t.text     "data"
                   t.datetime "updated_at"
                 end
                 add_index "sessions", ["session_id"], :name => "index_sessions_on_session_id"
                 add_index "sessions", ["updated_at"], :name => "index_sessions_on_updated_at"
                 create_table "sites", :force => true do |t|
                   t.string   "name"
                   t.boolean  "started"
                   t.datetime "start_time"
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.integer  "country_id"
                   t.string   "password"
                 end
                 create_table "submissions", :force => true do |t|
                   t.integer  "user_id"
                   t.integer  "problem_id"
                   t.integer  "language_id"
                   t.text     "source"
                   t.binary   "binary"
                   t.datetime "submitted_at"
                   t.datetime "compiled_at"
                   t.text     "compiler_message"
                   t.datetime "graded_at"
                   t.integer  "points"
                   t.text     "grader_comment"
                   t.integer  "number"
                   t.string   "source_filename"
                 end
                 add_index "submissions", ["user_id", "problem_id", "number"], :name => "index_submissions_on_user_id_and_problem_id_and_number", :unique => true
                 add_index "submissions", ["user_id", "problem_id"], :name => "index_submissions_on_user_id_and_problem_id"
                 create_table "tasks", :force => true do |t|
                   t.integer  "submission_id"
                   t.datetime "created_at"
                   t.integer  "status"
                   t.datetime "updated_at"
                 end
+            +   create_table "test_pair_assignments", :force => true do |t|
+            +     t.integer  "user_id"
+            +     t.integer  "problem_id"
+            +     t.integer  "test_pair_id"
+            +     t.integer  "test_pair_number"
+            +     t.integer  "request_number"
+            +     t.datetime "created_at"
+            +     t.datetime "updated_at"
+            +     t.boolean  "submitted"
+            +   end
+            +
                 create_table "test_pairs", :force => true do |t|
                   t.integer  "problem_id"
                   t.text     "input"
                   t.text     "solution"
                   t.datetime "created_at"
                   t.datetime "updated_at"
+            +     t.integer  "number"
                 end
                 create_table "test_requests", :force => true do |t|
                   t.integer  "user_id"
                   t.integer  "problem_id"
                   t.integer  "submission_id"
                   t.string   "input_file_name"
                   t.string   "output_file_name"
                   t.string   "running_stat"
                   t.integer  "status"
                   t.datetime "updated_at"
                   t.datetime "submitted_at"
                   t.datetime "compiled_at"
                   t.text     "compiler_message"
                   t.datetime "graded_at"
                   t.string   "grader_comment"
                   t.datetime "created_at"
                   t.float    "running_time"
                   t.string   "exit_status"
                   t.integer  "memory_usage"
                 end
                 add_index "test_requests", ["user_id", "problem_id"], :name => "index_test_requests_on_user_id_and_problem_id"
                 create_table "users", :force => true do |t|
                   t.string   "login",           :limit => 50
                   t.string   "full_name"
                   t.string   "hashed_password"
                   t.string   "salt",            :limit => 5
                   t.string   "alias"
                   t.string   "email"
                   t.integer  "site_id"
                   t.integer  "country_id"
                   t.boolean  "activated",                     :default => false
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 add_index "users", ["login"], :name => "index_users_on_login", :unique => true
               end

lib/testdata_importer.rb ¶ +3

                 def initialize(problem)
                   @problem = problem
                 end
                 def import_from_file(tempfile,
                                      time_limit,
                                      memory_limit,
                                      import_to_db=false)
                   dirname = extract(tempfile)
                   return false if not dirname
                   if not import_to_db
                     @log_msg = GraderScript.call_import_problem(@problem.name,
                                                                 dirname,
                                                                 time_limit,
                                                                 memory_limit)
                   else
                     # Import test data to test pairs.
                     @problem.test_pairs.clear
                     if import_test_pairs(dirname)
                       test_pair_count = TestPair.count :conditions => "problem_id = #{@problem.id}"
                       @log_msg = "Importing test pair successful. (#{test_pair_count} test pairs imported)"
                     else
                       @log_msg = "Importing test pair failed. (0 test pairs imported)"
                     end
                   end
                   @log_msg << import_problem_description(dirname)
                   return true
                 end
                 protected
                 def self.long_ext(filename)
                   i = filename.index('.')
                   len = filename.length
                   return filename.slice(i..len)
                 end
                 def extract(tempfile)
                   testdata_filename = save_testdata_file(tempfile)
                   ext = TestdataImporter.long_ext(tempfile.original_filename)
                   extract_dir = File.join(GraderScript.raw_dir, @problem.name)
                   begin
                     Dir.mkdir extract_dir
                   rescue Errno::EEXIST
                   end
                   if ext=='.tar.gz' or ext=='.tgz'
                     cmd = "tar -zxvf #{testdata_filename} -C #{extract_dir}"
                   elsif ext=='.tar'
                     cmd = "tar -xvf #{testdata_filename} -C #{extract_dir}"
                   elsif ext=='.zip'
                     cmd = "unzip -o #{testdata_filename} -d #{extract_dir}"
                   else
                     return nil
                   end
                   system(cmd)
                   files = Dir["#{extract_dir}/**/*1*.in"]
                   return nil if files.length==0
                   return File.dirname(files[0])
                 end
                 def save_testdata_file(tempfile)
                   ext = TestdataImporter.long_ext(tempfile.original_filename)
                   testdata_filename = File.join(Dir.tmpdir,"#{@problem.name}#{ext}")
                   return nil if tempfile==""
                   if tempfile.instance_of?(Tempfile)
                     tempfile.close
                     FileUtils.move(tempfile.path,testdata_filename)
                   else
                     File.open(testdata_filename, "wb") do |f|
                       f.write(tempfile.read)
                     end
                   end
                   return testdata_filename
                 end
                 def import_test_pairs(dirname)
                   test_num = 1
                   while FileTest.exists? "#{dirname}/#{test_num}.in"
                     in_filename = "#{dirname}/#{test_num}.in"
                     sol_filename = "#{dirname}/#{test_num}.sol"
                     break if not FileTest.exists? sol_filename
+            +       puts "#{dirname}"
+            +
                     test_pair = TestPair.new(:input => open(in_filename).read,
                                              :solution => open(sol_filename).read,
+            +                                :number => test_num,
                                              :problem => @problem)
                     break if not test_pair.save
                     test_num += 1
                   end
                   return test_num > 1
                 end
                 def import_problem_description(dirname)
                   html_files = Dir["#{dirname}/*.html"]
                   markdown_files = Dir["#{dirname}/*.md"] + Dir["#{dirname}/*.markdown"]
                   if (html_files.length != 0) or (markdown_files.length != 0)
                     description = @problem.description || Description.new
                     if html_files.length != 0
                       filename = html_files[0]
                       description.markdowned = false
                     else
                       filename = markdown_files[0]
                       description.markdowned = true
                     end
                     description.body = open(filename).read
                     description.save
                     @problem.description = description
                     @problem.save
                     return "\nProblem description imported from #{filename}."
                   end
                 end
               end

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

r213:805be1d05f2d - Mon, 18 Jan 2010 23:25:53 - 13 files changed: 178 inserted, 5 deleted

Sign in to your account

Commit r213:805be1d05f2d public

Author

r213:805be1d05f2d - Mon, 18 Jan 2010 23:25:53 - 13 files changed: 178 inserted, 5 deleted

Commit `r213:805be1d05f2d` public