Description:
added test pair assignment, requests new input, downloads input
Commit status:
[Not Reviewed]
References:
Diff options:
Comments:
0 Commit comments
0 Inline Comments
Unresolved TODOs:
There are no unresolved TODOs
Author
Jittat Fakcharoenphol
-
r213:805be1d05f2d - - 13 files changed: 178 inserted, 5 deleted
| @@ -0,0 +1,5 | |||
|
|
1 | + class TestPairAssignment < ActiveRecord::Base | |
|
|
2 | + belongs_to :user | |
|
|
3 | + belongs_to :test_pair | |
|
|
4 | + belongs_to :problem | |
|
|
5 | + end | |
| @@ -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 | |
| @@ -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 | |
| @@ -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 | |
| @@ -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 | |
| @@ -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 | |
| @@ -1,326 +1,357 | |||
|
|
1 | 1 | class MainController < ApplicationController |
|
|
2 | 2 | |
|
|
3 | 3 | SYSTEM_MODE_CONF_KEY = 'system.mode' |
|
|
4 | 4 | |
|
|
5 | 5 | before_filter :authenticate, :except => [:index, :login] |
|
|
6 | 6 | before_filter :check_viewability, :except => [:index, :login] |
|
|
7 | 7 | |
|
|
8 | 8 | # COMMENTED OUT: filter in each action instead |
|
|
9 | 9 | # before_filter :verify_time_limit, :only => [:submit] |
|
|
10 | 10 | |
|
|
11 | 11 | verify :method => :post, :only => [:submit], |
|
|
12 | 12 | :redirect_to => { :action => :index } |
|
|
13 | 13 | |
|
|
14 | 14 | # COMMENT OUT: only need when having high load |
|
|
15 | 15 | # caches_action :index, :login |
|
|
16 | 16 | |
|
|
17 | 17 | # NOTE: This method is not actually needed, 'config/routes.rb' has |
|
|
18 | 18 | # assigned action login as a default action. |
|
|
19 | 19 | def index |
|
|
20 | 20 | redirect_to :action => 'login' |
|
|
21 | 21 | end |
|
|
22 | 22 | |
|
|
23 | 23 | def login |
|
|
24 | 24 | saved_notice = flash[:notice] |
|
|
25 | 25 | reset_session |
|
|
26 | 26 | flash[:notice] = saved_notice |
|
|
27 | 27 | |
|
|
28 | 28 | # EXPERIMENT: |
|
|
29 | 29 | # Hide login if in single user mode and the url does not |
|
|
30 | 30 | # explicitly specify /login |
|
|
31 | 31 | # |
|
|
32 | 32 | # logger.info "PATH: #{request.path}" |
|
|
33 | 33 | # if Configuration['system.single_user_mode'] and |
|
|
34 | 34 | # request.path!='/main/login' |
|
|
35 | 35 | # @hidelogin = true |
|
|
36 | 36 | # end |
|
|
37 | 37 | |
|
|
38 | 38 | @announcements = Announcement.find_for_frontpage |
|
|
39 | 39 | render :action => 'login', :layout => 'empty' |
|
|
40 | 40 | end |
|
|
41 | 41 | |
|
|
42 | 42 | def list |
|
|
43 | 43 | prepare_list_information |
|
|
44 | 44 | end |
|
|
45 | 45 | |
|
|
46 | 46 | def help |
|
|
47 | 47 | @user = User.find(session[:user_id]) |
|
|
48 | 48 | end |
|
|
49 | 49 | |
|
|
50 | 50 | def submit |
|
|
51 | 51 | user = User.find(session[:user_id]) |
|
|
52 | 52 | |
|
|
53 | 53 | @submission = Submission.new(params[:submission]) |
|
|
54 | 54 | @submission.user = user |
|
|
55 | 55 | @submission.language_id = 0 |
|
|
56 | 56 | if (params['file']) and (params['file']!='') |
|
|
57 | 57 | @submission.source = params['file'].read |
|
|
58 | 58 | @submission.source_filename = params['file'].original_filename |
|
|
59 | 59 | end |
|
|
60 | 60 | @submission.submitted_at = Time.new.gmtime |
|
|
61 | 61 | |
|
|
62 | 62 | if Configuration[SYSTEM_MODE_CONF_KEY]=='contest' and |
|
|
63 | 63 | user.site!=nil and user.site.finished? |
|
|
64 | 64 | @submission.errors.add_to_base "The contest is over." |
|
|
65 | 65 | prepare_list_information |
|
|
66 | 66 | render :action => 'list' and return |
|
|
67 | 67 | end |
|
|
68 | 68 | |
|
|
69 | 69 | if @submission.valid? |
|
|
70 | 70 | if @submission.save == false |
|
|
71 | 71 | flash[:notice] = 'Error saving your submission' |
|
|
72 | 72 | elsif Task.create(:submission_id => @submission.id, |
|
|
73 | 73 | :status => Task::STATUS_INQUEUE) == false |
|
|
74 | 74 | flash[:notice] = 'Error adding your submission to task queue' |
|
|
75 | 75 | end |
|
|
76 | 76 | else |
|
|
77 | 77 | prepare_list_information |
|
|
78 | 78 | render :action => 'list' and return |
|
|
79 | 79 | end |
|
|
80 | 80 | redirect_to :action => 'list' |
|
|
81 | 81 | end |
|
|
82 | 82 | |
|
|
83 | 83 | def source |
|
|
84 | 84 | submission = Submission.find(params[:id]) |
|
|
85 | 85 | if submission.user_id == session[:user_id] |
|
|
86 | 86 | send_data(submission.source, |
|
|
87 | 87 | {:filename => submission.download_filename, |
|
|
88 | 88 | :type => 'text/plain'}) |
|
|
89 | 89 | else |
|
|
90 | 90 | flash[:notice] = 'Error viewing source' |
|
|
91 | 91 | redirect_to :action => 'list' |
|
|
92 | 92 | end |
|
|
93 | 93 | end |
|
|
94 | 94 | |
|
|
95 | 95 | def compiler_msg |
|
|
96 | 96 | @submission = Submission.find(params[:id]) |
|
|
97 | 97 | if @submission.user_id == session[:user_id] |
|
|
98 | 98 | render :action => 'compiler_msg', :layout => 'empty' |
|
|
99 | 99 | else |
|
|
100 | 100 | flash[:notice] = 'Error viewing source' |
|
|
101 | 101 | redirect_to :action => 'list' |
|
|
102 | 102 | end |
|
|
103 | 103 | end |
|
|
104 | 104 | |
|
|
105 | 105 | def submission |
|
|
106 | 106 | @user = User.find(session[:user_id]) |
|
|
107 | 107 | @problems = Problem.find_available_problems |
|
|
108 | 108 | if params[:id]==nil |
|
|
109 | 109 | @problem = nil |
|
|
110 | 110 | @submissions = nil |
|
|
111 | 111 | else |
|
|
112 | 112 | @problem = Problem.find_by_name(params[:id]) |
|
|
113 | 113 | if not @problem.available |
|
|
114 | 114 | redirect_to :action => 'list' |
|
|
115 | 115 | flash[:notice] = 'Error: submissions for that problem are not viewable.' |
|
|
116 | 116 | return |
|
|
117 | 117 | end |
|
|
118 | 118 | @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id) |
|
|
119 | 119 | end |
|
|
120 | 120 | end |
|
|
121 | 121 | |
|
|
122 | 122 | def result |
|
|
123 | 123 | if !Configuration.show_grading_result |
|
|
124 | 124 | redirect_to :action => 'list' and return |
|
|
125 | 125 | end |
|
|
126 | 126 | @user = User.find(session[:user_id]) |
|
|
127 | 127 | @submission = Submission.find(params[:id]) |
|
|
128 | 128 | if @submission.user!=@user |
|
|
129 | 129 | flash[:notice] = 'You are not allowed to view result of other users.' |
|
|
130 | 130 | redirect_to :action => 'list' and return |
|
|
131 | 131 | end |
|
|
132 | 132 | prepare_grading_result(@submission) |
|
|
133 | 133 | end |
|
|
134 | 134 | |
|
|
135 | 135 | def load_output |
|
|
136 | 136 | if !Configuration.show_grading_result or params[:num]==nil |
|
|
137 | 137 | redirect_to :action => 'list' and return |
|
|
138 | 138 | end |
|
|
139 | 139 | @user = User.find(session[:user_id]) |
|
|
140 | 140 | @submission = Submission.find(params[:id]) |
|
|
141 | 141 | if @submission.user!=@user |
|
|
142 | 142 | flash[:notice] = 'You are not allowed to view result of other users.' |
|
|
143 | 143 | redirect_to :action => 'list' and return |
|
|
144 | 144 | end |
|
|
145 | 145 | case_num = params[:num].to_i |
|
|
146 | 146 | out_filename = output_filename(@user.login, |
|
|
147 | 147 | @submission.problem.name, |
|
|
148 | 148 | @submission.id, |
|
|
149 | 149 | case_num) |
|
|
150 | 150 | if !FileTest.exists?(out_filename) |
|
|
151 | 151 | flash[:notice] = 'Output not found.' |
|
|
152 | 152 | redirect_to :action => 'list' and return |
|
|
153 | 153 | end |
|
|
154 | 154 | |
|
|
155 | 155 | response.headers['Content-Type'] = "application/force-download" |
|
|
156 | 156 | response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\"" |
|
|
157 | 157 | response.headers["X-Sendfile"] = out_filename |
|
|
158 | 158 | response.headers['Content-length'] = File.size(out_filename) |
|
|
159 | 159 | render :nothing => true |
|
|
160 | 160 | end |
|
|
161 | 161 | |
|
|
162 | 162 | def error |
|
|
163 | 163 | @user = User.find(session[:user_id]) |
|
|
164 | 164 | end |
|
|
165 | 165 | |
|
|
166 | 166 | # announcement refreshing and hiding methods |
|
|
167 | 167 | |
|
|
168 | 168 | def announcements |
|
|
169 | 169 | if params.has_key? 'recent' |
|
|
170 | 170 | prepare_announcements(params[:recent]) |
|
|
171 | 171 | else |
|
|
172 | 172 | prepare_announcements |
|
|
173 | 173 | end |
|
|
174 | 174 | render(:partial => 'announcement', |
|
|
175 | 175 | :collection => @announcements, |
|
|
176 | 176 | :locals => {:announcement_effect => true}) |
|
|
177 | 177 | end |
|
|
178 | 178 | |
|
|
179 | + # actions for Code Jom | |
|
|
180 | + def new_input | |
|
|
181 | + problem = Problem.find(params[:id]) | |
|
|
182 | + user = User.find(session[:user_id]) | |
|
|
183 | + if user.can_request_new_test_pair_for? problem | |
|
|
184 | + assignment = user.get_new_test_pair_assignment_for problem | |
|
|
185 | + assignment.save | |
|
|
186 | + | |
|
|
187 | + send_data(assignment.test_pair.input, | |
|
|
188 | + { :filename => "#{problem.name}-#{assignment.request_number}.in", | |
|
|
189 | + :type => 'text/plain' }) | |
|
|
190 | + else | |
|
|
191 | + flash[:notice] = 'You cannot request new input now.' | |
|
|
192 | + redirect_to :action => 'list' | |
|
|
193 | + end | |
|
|
194 | + end | |
|
|
195 | + | |
|
|
196 | + def download | |
|
|
197 | + problem = Problem.find(params[:id]) | |
|
|
198 | + user = User.find(session[:user_id]) | |
|
|
199 | + recent_assignment = user.get_recent_test_pair_assignment_for problem | |
|
|
200 | + if recent_assignment != nil | |
|
|
201 | + send_data(recent_assignment.test_pair.input, | |
|
|
202 | + { :filename => "#{problem.name}-#{recent_assignment.request_number}.in", | |
|
|
203 | + :type => 'text/plain' }) | |
|
|
204 | + else | |
|
|
205 | + flash[:notice] = 'You have not request for any input data for this problem.' | |
|
|
206 | + redirect_to :action => 'list' | |
|
|
207 | + end | |
|
|
208 | + end | |
|
|
209 | + | |
|
|
179 | 210 | protected |
|
|
180 | 211 | |
|
|
181 | 212 | def prepare_announcements(recent=nil) |
|
|
182 | 213 | if Configuration.show_tasks_to?(@user) |
|
|
183 | 214 | @announcements = Announcement.find_published(true) |
|
|
184 | 215 | else |
|
|
185 | 216 | @announcements = Announcement.find_published |
|
|
186 | 217 | end |
|
|
187 | 218 | if recent!=nil |
|
|
188 | 219 | recent_id = recent.to_i |
|
|
189 | 220 | @announcements = @announcements.find_all { |a| a.id > recent_id } |
|
|
190 | 221 | end |
|
|
191 | 222 | end |
|
|
192 | 223 | |
|
|
193 | 224 | def prepare_list_information |
|
|
194 | 225 | @problems = Problem.find_available_problems |
|
|
195 | 226 | @prob_submissions = Array.new |
|
|
196 | 227 | @user = User.find(session[:user_id]) |
|
|
197 | 228 | @problems.each do |p| |
|
|
198 | 229 | sub = Submission.find_last_by_user_and_problem(@user.id,p.id) |
|
|
199 | 230 | if sub!=nil |
|
|
200 | 231 | @prob_submissions << { :count => sub.number, :submission => sub } |
|
|
201 | 232 | else |
|
|
202 | 233 | @prob_submissions << { :count => 0, :submission => nil } |
|
|
203 | 234 | end |
|
|
204 | 235 | end |
|
|
205 | 236 | prepare_announcements |
|
|
206 | 237 | end |
|
|
207 | 238 | |
|
|
208 | 239 | def check_viewability |
|
|
209 | 240 | @user = User.find(session[:user_id]) |
|
|
210 | 241 | if (!Configuration.show_tasks_to?(@user)) and |
|
|
211 | 242 | ((action_name=='submission') or (action_name=='submit')) |
|
|
212 | 243 | redirect_to :action => 'list' and return |
|
|
213 | 244 | end |
|
|
214 | 245 | end |
|
|
215 | 246 | |
|
|
216 | 247 | def prepare_grading_result(submission) |
|
|
217 | 248 | if Configuration.task_grading_info.has_key? submission.problem.name |
|
|
218 | 249 | grading_info = Configuration.task_grading_info[submission.problem.name] |
|
|
219 | 250 | else |
|
|
220 | 251 | # guess task info from problem.full_score |
|
|
221 | 252 | cases = submission.problem.full_score / 10 |
|
|
222 | 253 | grading_info = { |
|
|
223 | 254 | 'testruns' => cases, |
|
|
224 | 255 | 'testcases' => cases |
|
|
225 | 256 | } |
|
|
226 | 257 | end |
|
|
227 | 258 | @test_runs = [] |
|
|
228 | 259 | if grading_info['testruns'].is_a? Integer |
|
|
229 | 260 | trun_count = grading_info['testruns'] |
|
|
230 | 261 | trun_count.times do |i| |
|
|
231 | 262 | @test_runs << [ read_grading_result(@user.login, |
|
|
232 | 263 | submission.problem.name, |
|
|
233 | 264 | submission.id, |
|
|
234 | 265 | i+1) ] |
|
|
235 | 266 | end |
|
|
236 | 267 | else |
|
|
237 | 268 | grading_info['testruns'].keys.sort.each do |num| |
|
|
238 | 269 | run = [] |
|
|
239 | 270 | testrun = grading_info['testruns'][num] |
|
|
240 | 271 | testrun.each do |c| |
|
|
241 | 272 | run << read_grading_result(@user.login, |
|
|
242 | 273 | submission.problem.name, |
|
|
243 | 274 | submission.id, |
|
|
244 | 275 | c) |
|
|
245 | 276 | end |
|
|
246 | 277 | @test_runs << run |
|
|
247 | 278 | end |
|
|
248 | 279 | end |
|
|
249 | 280 | end |
|
|
250 | 281 | |
|
|
251 | 282 | def grading_result_dir(user_name, problem_name, submission_id, case_num) |
|
|
252 | 283 | return "#{GRADING_RESULT_DIR}/#{user_name}/#{problem_name}/#{submission_id}/test-result/#{case_num}" |
|
|
253 | 284 | end |
|
|
254 | 285 | |
|
|
255 | 286 | def output_filename(user_name, problem_name, submission_id, case_num) |
|
|
256 | 287 | dir = grading_result_dir(user_name,problem_name, submission_id, case_num) |
|
|
257 | 288 | return "#{dir}/output.txt" |
|
|
258 | 289 | end |
|
|
259 | 290 | |
|
|
260 | 291 | def read_grading_result(user_name, problem_name, submission_id, case_num) |
|
|
261 | 292 | dir = grading_result_dir(user_name,problem_name, submission_id, case_num) |
|
|
262 | 293 | result_file_name = "#{dir}/result" |
|
|
263 | 294 | if !FileTest.exists?(result_file_name) |
|
|
264 | 295 | return {:num => case_num, :msg => 'program did not run'} |
|
|
265 | 296 | else |
|
|
266 | 297 | results = File.open(result_file_name).readlines |
|
|
267 | 298 | run_stat = extract_running_stat(results) |
|
|
268 | 299 | output_filename = "#{dir}/output.txt" |
|
|
269 | 300 | if FileTest.exists?(output_filename) |
|
|
270 | 301 | output_file = true |
|
|
271 | 302 | output_size = File.size(output_filename) |
|
|
272 | 303 | else |
|
|
273 | 304 | output_file = false |
|
|
274 | 305 | output_size = 0 |
|
|
275 | 306 | end |
|
|
276 | 307 | |
|
|
277 | 308 | return { |
|
|
278 | 309 | :num => case_num, |
|
|
279 | 310 | :msg => results[0], |
|
|
280 | 311 | :run_stat => run_stat, |
|
|
281 | 312 | :output => output_file, |
|
|
282 | 313 | :output_size => output_size |
|
|
283 | 314 | } |
|
|
284 | 315 | end |
|
|
285 | 316 | end |
|
|
286 | 317 | |
|
|
287 | 318 | # copied from grader/script/lib/test_request_helper.rb |
|
|
288 | 319 | def extract_running_stat(results) |
|
|
289 | 320 | running_stat_line = results[-1] |
|
|
290 | 321 | |
|
|
291 | 322 | # extract exit status line |
|
|
292 | 323 | run_stat = "" |
|
|
293 | 324 | if !(/[Cc]orrect/.match(results[0])) |
|
|
294 | 325 | run_stat = results[0].chomp |
|
|
295 | 326 | else |
|
|
296 | 327 | run_stat = 'Program exited normally' |
|
|
297 | 328 | end |
|
|
298 | 329 | |
|
|
299 | 330 | logger.info "Stat line: #{running_stat_line}" |
|
|
300 | 331 | |
|
|
301 | 332 | # extract running time |
|
|
302 | 333 | if res = /r(.*)u(.*)s/.match(running_stat_line) |
|
|
303 | 334 | seconds = (res[1].to_f + res[2].to_f) |
|
|
304 | 335 | time_stat = "Time used: #{seconds} sec." |
|
|
305 | 336 | else |
|
|
306 | 337 | seconds = nil |
|
|
307 | 338 | time_stat = "Time used: n/a sec." |
|
|
308 | 339 | end |
|
|
309 | 340 | |
|
|
310 | 341 | # extract memory usage |
|
|
311 | 342 | if res = /s(.*)m/.match(running_stat_line) |
|
|
312 | 343 | memory_used = res[1].to_i |
|
|
313 | 344 | else |
|
|
314 | 345 | memory_used = -1 |
|
|
315 | 346 | end |
|
|
316 | 347 | |
|
|
317 | 348 | return { |
|
|
318 | 349 | :msg => "#{run_stat}\n#{time_stat}", |
|
|
319 | 350 | :running_time => seconds, |
|
|
320 | 351 | :exit_status => run_stat, |
|
|
321 | 352 | :memory_usage => memory_used |
|
|
322 | 353 | } |
|
|
323 | 354 | end |
|
|
324 | 355 | |
|
|
325 | 356 | end |
|
|
326 | 357 | |
| @@ -1,101 +1,116 | |||
|
|
1 | 1 | class Problem < ActiveRecord::Base |
|
|
2 | 2 | |
|
|
3 | 3 | belongs_to :description |
|
|
4 | 4 | has_many :test_pairs, :dependent => :delete_all |
|
|
5 | 5 | |
|
|
6 | 6 | validates_presence_of :name |
|
|
7 | 7 | validates_format_of :name, :with => /^\w+$/ |
|
|
8 | 8 | validates_presence_of :full_name |
|
|
9 | 9 | |
|
|
10 | 10 | DEFAULT_TIME_LIMIT = 1 |
|
|
11 | 11 | DEFAULT_MEMORY_LIMIT = 32 |
|
|
12 | 12 | |
|
|
13 | + def test_pair_count | |
|
|
14 | + @test_pair_count ||= test_pairs.size | |
|
|
15 | + end | |
|
|
16 | + | |
|
|
17 | + def uses_random_test_pair? | |
|
|
18 | + test_pair_count != 0 | |
|
|
19 | + end | |
|
|
20 | + | |
|
|
21 | + def random_test_pair(forbidden_numbers=nil) | |
|
|
22 | + begin | |
|
|
23 | + test_num = 1 + rand(test_pair_count) | |
|
|
24 | + end while forbidden_numbers!=nil and forbidden_numbers.include? test_num | |
|
|
25 | + test_pairs.find_by_number test_num | |
|
|
26 | + end | |
|
|
27 | + | |
|
|
13 | 28 | def self.find_available_problems |
|
|
14 | 29 | find(:all, :conditions => {:available => true}, :order => "date_added DESC") |
|
|
15 | 30 | end |
|
|
16 | 31 | |
|
|
17 | 32 | def self.create_from_import_form_params(params, old_problem=nil) |
|
|
18 | 33 | problem = old_problem || Problem.new |
|
|
19 | 34 | import_params = Problem.extract_params_and_check(params, problem) |
|
|
20 | 35 | |
|
|
21 | 36 | if not problem.valid? |
|
|
22 | 37 | return problem, 'Error importing' |
|
|
23 | 38 | end |
|
|
24 | 39 | |
|
|
25 | 40 | problem.full_score = 100 |
|
|
26 | 41 | problem.date_added = Time.new |
|
|
27 | 42 | problem.test_allowed = true |
|
|
28 | 43 | problem.output_only = false |
|
|
29 | 44 | problem.available = false |
|
|
30 | 45 | |
|
|
31 | 46 | if not problem.save |
|
|
32 | 47 | return problem, 'Error importing' |
|
|
33 | 48 | end |
|
|
34 | 49 | |
|
|
35 | 50 | import_to_db = params.has_key? :import_to_db |
|
|
36 | 51 | |
|
|
37 | 52 | importer = TestdataImporter.new(problem) |
|
|
38 | 53 | |
|
|
39 | 54 | if not importer.import_from_file(import_params[:file], |
|
|
40 | 55 | import_params[:time_limit], |
|
|
41 | 56 | import_params[:memory_limit], |
|
|
42 | 57 | import_to_db) |
|
|
43 | 58 | problem.errors.add_to_base('Import error.') |
|
|
44 | 59 | end |
|
|
45 | 60 | |
|
|
46 | 61 | return problem, importer.log_msg |
|
|
47 | 62 | end |
|
|
48 | 63 | |
|
|
49 | 64 | protected |
|
|
50 | 65 | |
|
|
51 | 66 | def self.to_i_or_default(st, default) |
|
|
52 | 67 | if st!='' |
|
|
53 | 68 | st.to_i |
|
|
54 | 69 | else |
|
|
55 | 70 | default |
|
|
56 | 71 | end |
|
|
57 | 72 | end |
|
|
58 | 73 | |
|
|
59 | 74 | def self.extract_params_and_check(params, problem) |
|
|
60 | 75 | time_limit = Problem.to_i_or_default(params[:time_limit], |
|
|
61 | 76 | DEFAULT_TIME_LIMIT) |
|
|
62 | 77 | memory_limit = Problem.to_i_or_default(params[:memory_limit], |
|
|
63 | 78 | DEFAULT_MEMORY_LIMIT) |
|
|
64 | 79 | |
|
|
65 | 80 | if time_limit==0 and time_limit_s!='0' |
|
|
66 | 81 | problem.errors.add_to_base('Time limit format errors.') |
|
|
67 | 82 | elsif time_limit<=0 or time_limit >60 |
|
|
68 | 83 | problem.errors.add_to_base('Time limit out of range.') |
|
|
69 | 84 | end |
|
|
70 | 85 | |
|
|
71 | 86 | if memory_limit==0 and memory_limit_s!='0' |
|
|
72 | 87 | problem.errors.add_to_base('Memory limit format errors.') |
|
|
73 | 88 | elsif memory_limit<=0 or memory_limit >512 |
|
|
74 | 89 | problem.errors.add_to_base('Memory limit out of range.') |
|
|
75 | 90 | end |
|
|
76 | 91 | |
|
|
77 | 92 | if params[:file]==nil or params[:file]=='' |
|
|
78 | 93 | problem.errors.add_to_base('No testdata file.') |
|
|
79 | 94 | end |
|
|
80 | 95 | |
|
|
81 | 96 | file = params[:file] |
|
|
82 | 97 | |
|
|
83 | 98 | if problem.errors.length!=0 |
|
|
84 | 99 | return problem |
|
|
85 | 100 | end |
|
|
86 | 101 | |
|
|
87 | 102 | problem.name = params[:name] |
|
|
88 | 103 | if params[:full_name]!='' |
|
|
89 | 104 | problem.full_name = params[:full_name] |
|
|
90 | 105 | else |
|
|
91 | 106 | problem.full_name = params[:name] |
|
|
92 | 107 | end |
|
|
93 | 108 | |
|
|
94 | 109 | return { |
|
|
95 | 110 | :time_limit => time_limit, |
|
|
96 | 111 | :memory_limit => memory_limit, |
|
|
97 | 112 | :file => file |
|
|
98 | 113 | } |
|
|
99 | 114 | end |
|
|
100 | 115 | |
|
|
101 | 116 | end |
| @@ -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 | 7 | class TestPair < ActiveRecord::Base |
|
|
2 | 8 | belongs_to :problem |
|
|
3 | 9 | end |
| @@ -1,174 +1,218 | |||
|
|
1 | 1 | require 'digest/sha1' |
|
|
2 | 2 | |
|
|
3 | 3 | class User < ActiveRecord::Base |
|
|
4 | 4 | |
|
|
5 | 5 | has_and_belongs_to_many :roles |
|
|
6 | 6 | |
|
|
7 | 7 | has_many :test_requests, :order => "submitted_at DESC" |
|
|
8 | 8 | |
|
|
9 | 9 | has_many :messages, |
|
|
10 | 10 | :class_name => "Message", |
|
|
11 | 11 | :foreign_key => "sender_id", |
|
|
12 | 12 | :order => 'created_at DESC' |
|
|
13 | 13 | |
|
|
14 | 14 | has_many :replied_messages, |
|
|
15 | 15 | :class_name => "Message", |
|
|
16 | 16 | :foreign_key => "receiver_id", |
|
|
17 | 17 | :order => 'created_at DESC' |
|
|
18 | 18 | |
|
|
19 | + has_many :test_pair_assignments, :dependent => :delete_all | |
|
|
20 | + | |
|
|
19 | 21 | belongs_to :site |
|
|
20 | 22 | belongs_to :country |
|
|
21 | 23 | |
|
|
22 | 24 | named_scope :activated_users, :conditions => {:activated => true} |
|
|
23 | 25 | |
|
|
24 | 26 | validates_presence_of :login |
|
|
25 | 27 | validates_uniqueness_of :login |
|
|
26 | 28 | validates_format_of :login, :with => /^[\_A-Za-z0-9]+$/ |
|
|
27 | 29 | validates_length_of :login, :within => 3..30 |
|
|
28 | 30 | |
|
|
29 | 31 | validates_presence_of :full_name |
|
|
30 | 32 | validates_length_of :full_name, :minimum => 1 |
|
|
31 | 33 | |
|
|
32 | 34 | validates_presence_of :password, :if => :password_required? |
|
|
33 | 35 | validates_length_of :password, :within => 4..20, :if => :password_required? |
|
|
34 | 36 | validates_confirmation_of :password, :if => :password_required? |
|
|
35 | 37 | |
|
|
36 | 38 | validates_format_of :email, |
|
|
37 | 39 | :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, |
|
|
38 | 40 | :if => :email_validation? |
|
|
39 | 41 | validate :uniqueness_of_email_from_activated_users, |
|
|
40 | 42 | :if => :email_validation? |
|
|
41 | 43 | validate :enough_time_interval_between_same_email_registrations, |
|
|
42 | 44 | :if => :email_validation? |
|
|
43 | 45 | |
|
|
44 | 46 | # these are for ytopc |
|
|
45 | 47 | # disable for now |
|
|
46 | 48 | #validates_presence_of :province |
|
|
47 | 49 | |
|
|
48 | 50 | attr_accessor :password |
|
|
49 | 51 | |
|
|
50 | 52 | before_save :encrypt_new_password |
|
|
51 | 53 | before_save :assign_default_site |
|
|
52 | 54 | |
|
|
53 | 55 | def self.authenticate(login, password) |
|
|
54 | 56 | user = find_by_login(login) |
|
|
55 | 57 | return user if user && user.authenticated?(password) |
|
|
56 | 58 | end |
|
|
57 | 59 | |
|
|
58 | 60 | def authenticated?(password) |
|
|
59 | 61 | if self.activated |
|
|
60 | 62 | hashed_password == User.encrypt(password,self.salt) |
|
|
61 | 63 | else |
|
|
62 | 64 | false |
|
|
63 | 65 | end |
|
|
64 | 66 | end |
|
|
65 | 67 | |
|
|
66 | 68 | def admin? |
|
|
67 | 69 | self.roles.detect {|r| r.name == 'admin' } |
|
|
68 | 70 | end |
|
|
69 | 71 | |
|
|
72 | + # These are methods related to test pairs | |
|
|
73 | + | |
|
|
74 | + def get_test_pair_assignments_for(problem) | |
|
|
75 | + test_pair_assignments.find_all { |a| a.problem_id == problem.id } | |
|
|
76 | + end | |
|
|
77 | + | |
|
|
78 | + def get_recent_test_pair_assignment_for(problem) | |
|
|
79 | + assignments = get_test_pair_assignments_for problem | |
|
|
80 | + if assignments.length == 0 | |
|
|
81 | + return nil | |
|
|
82 | + else | |
|
|
83 | + recent = assignments[0] | |
|
|
84 | + assignments.each do |a| | |
|
|
85 | + recent = a if a.request_number > recent.request_number | |
|
|
86 | + end | |
|
|
87 | + return recent | |
|
|
88 | + end | |
|
|
89 | + end | |
|
|
90 | + | |
|
|
91 | + def can_request_new_test_pair_for?(problem) | |
|
|
92 | + recent = get_recent_test_pair_assignment_for problem | |
|
|
93 | + return (recent == nil or recent.submitted) | |
|
|
94 | + end | |
|
|
95 | + | |
|
|
96 | + def get_new_test_pair_assignment_for(problem) | |
|
|
97 | + previous_assignment_numbers = | |
|
|
98 | + get_test_pair_assignments_for(problem).collect {|a| a.test_pair_number } | |
|
|
99 | + test_pair = problem.random_test_pair(previous_assignment_numbers) | |
|
|
100 | + if test_pair | |
|
|
101 | + assignment = TestPairAssignment.new(:user => self, | |
|
|
102 | + :problem => problem, | |
|
|
103 | + :test_pair => test_pair, | |
|
|
104 | + :test_pair_number => test_pair.number, | |
|
|
105 | + :request_number => | |
|
|
106 | + previous_assignment_numbers.length + 1, | |
|
|
107 | + :submitted => false) | |
|
|
108 | + return assignment | |
|
|
109 | + else | |
|
|
110 | + return nil | |
|
|
111 | + end | |
|
|
112 | + end | |
|
|
113 | + | |
|
|
70 | 114 | def email_for_editing |
|
|
71 | 115 | if self.email==nil |
|
|
72 | 116 | "(unknown)" |
|
|
73 | 117 | elsif self.email=='' |
|
|
74 | 118 | "(blank)" |
|
|
75 | 119 | else |
|
|
76 | 120 | self.email |
|
|
77 | 121 | end |
|
|
78 | 122 | end |
|
|
79 | 123 | |
|
|
80 | 124 | def email_for_editing=(e) |
|
|
81 | 125 | self.email=e |
|
|
82 | 126 | end |
|
|
83 | 127 | |
|
|
84 | 128 | def alias_for_editing |
|
|
85 | 129 | if self.alias==nil |
|
|
86 | 130 | "(unknown)" |
|
|
87 | 131 | elsif self.alias=='' |
|
|
88 | 132 | "(blank)" |
|
|
89 | 133 | else |
|
|
90 | 134 | self.alias |
|
|
91 | 135 | end |
|
|
92 | 136 | end |
|
|
93 | 137 | |
|
|
94 | 138 | def alias_for_editing=(e) |
|
|
95 | 139 | self.alias=e |
|
|
96 | 140 | end |
|
|
97 | 141 | |
|
|
98 | 142 | def activation_key |
|
|
99 | 143 | if self.hashed_password==nil |
|
|
100 | 144 | encrypt_new_password |
|
|
101 | 145 | end |
|
|
102 | 146 | Digest::SHA1.hexdigest(self.hashed_password)[0..7] |
|
|
103 | 147 | end |
|
|
104 | 148 | |
|
|
105 | 149 | def verify_activation_key(key) |
|
|
106 | 150 | key == activation_key |
|
|
107 | 151 | end |
|
|
108 | 152 | |
|
|
109 | 153 | def self.random_password(length=5) |
|
|
110 | 154 | chars = 'abcdefghjkmnopqrstuvwxyz' |
|
|
111 | 155 | password = '' |
|
|
112 | 156 | length.times { password << chars[rand(chars.length - 1)] } |
|
|
113 | 157 | password |
|
|
114 | 158 | end |
|
|
115 | 159 | |
|
|
116 | 160 | def self.find_non_admin_with_prefix(prefix='') |
|
|
117 | 161 | users = User.find(:all) |
|
|
118 | 162 | return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 } |
|
|
119 | 163 | end |
|
|
120 | 164 | |
|
|
121 | 165 | protected |
|
|
122 | 166 | def encrypt_new_password |
|
|
123 | 167 | return if password.blank? |
|
|
124 | 168 | self.salt = (10+rand(90)).to_s |
|
|
125 | 169 | self.hashed_password = User.encrypt(self.password,self.salt) |
|
|
126 | 170 | end |
|
|
127 | 171 | |
|
|
128 | 172 | def assign_default_site |
|
|
129 | 173 | # have to catch error when migrating (because self.site is not available). |
|
|
130 | 174 | begin |
|
|
131 | 175 | if self.site==nil |
|
|
132 | 176 | self.site = Site.find_by_name('default') |
|
|
133 | 177 | if self.site==nil |
|
|
134 | 178 | self.site = Site.find(1) # when 'default has be renamed' |
|
|
135 | 179 | end |
|
|
136 | 180 | end |
|
|
137 | 181 | rescue |
|
|
138 | 182 | end |
|
|
139 | 183 | end |
|
|
140 | 184 | |
|
|
141 | 185 | def password_required? |
|
|
142 | 186 | self.hashed_password.blank? || !self.password.blank? |
|
|
143 | 187 | end |
|
|
144 | 188 | |
|
|
145 | 189 | def self.encrypt(string,salt) |
|
|
146 | 190 | Digest::SHA1.hexdigest(salt + string) |
|
|
147 | 191 | end |
|
|
148 | 192 | |
|
|
149 | 193 | def uniqueness_of_email_from_activated_users |
|
|
150 | 194 | user = User.activated_users.find_by_email(self.email) |
|
|
151 | 195 | if user and (user.login != self.login) |
|
|
152 | 196 | self.errors.add_to_base("Email has already been taken") |
|
|
153 | 197 | end |
|
|
154 | 198 | end |
|
|
155 | 199 | |
|
|
156 | 200 | def enough_time_interval_between_same_email_registrations |
|
|
157 | 201 | return if !self.new_record? |
|
|
158 | 202 | return if self.activated |
|
|
159 | 203 | open_user = User.find_by_email(self.email, |
|
|
160 | 204 | :order => 'created_at DESC') |
|
|
161 | 205 | if open_user and open_user.created_at and |
|
|
162 | 206 | (open_user.created_at > Time.now.gmtime - 5.minutes) |
|
|
163 | 207 | self.errors.add_to_base("There are already unactivated registrations with this e-mail address (please wait for 5 minutes)") |
|
|
164 | 208 | end |
|
|
165 | 209 | end |
|
|
166 | 210 | |
|
|
167 | 211 | def email_validation? |
|
|
168 | 212 | begin |
|
|
169 | 213 | return VALIDATE_USER_EMAILS |
|
|
170 | 214 | rescue |
|
|
171 | 215 | return false |
|
|
172 | 216 | end |
|
|
173 | 217 | end |
|
|
174 | 218 | end |
| @@ -1,18 +1,26 | |||
|
|
1 | 1 | <tr class="info-<%= (problem_counter%2==0) ? "even" : "odd" %>"> |
|
|
2 | 2 | <td> |
|
|
3 | 3 | <%= "#{problem_counter+1}" %> |
|
|
4 | 4 | </td> |
|
|
5 | 5 | <td> |
|
|
6 | 6 | <%= "#{problem.full_name} (#{problem.name})" %> |
|
|
7 | 7 | <%= link_to "[#{t 'main.problem_desc'}]", problem.url, :popup => true if (problem.url!=nil) and (problem.url!='') %> |
|
|
8 | 8 | </td> |
|
|
9 | 9 | <td align="center"> |
|
|
10 | 10 | <%= @prob_submissions[problem_counter][:count] %> |
|
|
11 | 11 | </td> |
|
|
12 | 12 | <td> |
|
|
13 | - <%= render :partial => 'submission_short', | |
|
|
14 | - :locals => { | |
|
|
15 | - :submission => @prob_submissions[problem_counter][:submission], | |
|
|
16 | - :problem_name => problem.name }%> | |
|
|
13 | + <span id="problem-form-<%= problem.id %>"> | |
|
|
14 | + <% form_tag "new_input/#{problem.id}", :method => :post do -%> | |
|
|
15 | + <input type="submit" value="New input"/> | |
|
|
16 | + <% end -%> | |
|
|
17 | + <% form_tag "download/#{problem.id}", :method => :post do -%> | |
|
|
18 | + <input type="submit" value="Download input"/> | |
|
|
19 | + <% end -%> | |
|
|
20 | + <% form_tag "submit_solution/#{problem.id}", :method => :post do -%> | |
|
|
21 | + <input type="file"> | |
|
|
22 | + <input type="submit" value="Submit solution"/> | |
|
|
23 | + <% end -%> | |
|
|
24 | + </span> | |
|
|
17 | 25 | </td> |
|
|
18 | 26 | </tr> |
| @@ -1,204 +1,216 | |||
|
|
1 | 1 | # This file is auto-generated from the current state of the database. Instead of editing this file, |
|
|
2 | 2 | # please use the migrations feature of Active Record to incrementally modify your database, and |
|
|
3 | 3 | # then regenerate this schema definition. |
|
|
4 | 4 | # |
|
|
5 | 5 | # Note that this schema.rb definition is the authoritative source for your database schema. If you need |
|
|
6 | 6 | # to create the application database on another system, you should be using db:schema:load, not running |
|
|
7 | 7 | # all the migrations from scratch. The latter is a flawed and unsustainable approach (the more migrations |
|
|
8 | 8 | # you'll amass, the slower it'll run and the greater likelihood for issues). |
|
|
9 | 9 | # |
|
|
10 | 10 | # It's strongly recommended to check this file into your version control system. |
|
|
11 | 11 | |
|
|
12 |
- ActiveRecord::Schema.define(:version => 2010011 |
|
|
|
12 | + ActiveRecord::Schema.define(:version => 20100118174404) do | |
|
|
13 | 13 | |
|
|
14 | 14 | create_table "announcements", :force => true do |t| |
|
|
15 | 15 | t.string "author" |
|
|
16 | 16 | t.text "body" |
|
|
17 | 17 | t.boolean "published" |
|
|
18 | 18 | t.datetime "created_at" |
|
|
19 | 19 | t.datetime "updated_at" |
|
|
20 | 20 | t.boolean "frontpage", :default => false |
|
|
21 | 21 | t.boolean "contest_only", :default => false |
|
|
22 | 22 | t.string "title" |
|
|
23 | 23 | end |
|
|
24 | 24 | |
|
|
25 | 25 | create_table "configurations", :force => true do |t| |
|
|
26 | 26 | t.string "key" |
|
|
27 | 27 | t.string "value_type" |
|
|
28 | 28 | t.string "value" |
|
|
29 | 29 | t.datetime "created_at" |
|
|
30 | 30 | t.datetime "updated_at" |
|
|
31 | 31 | end |
|
|
32 | 32 | |
|
|
33 | 33 | create_table "countries", :force => true do |t| |
|
|
34 | 34 | t.string "name" |
|
|
35 | 35 | t.datetime "created_at" |
|
|
36 | 36 | t.datetime "updated_at" |
|
|
37 | 37 | end |
|
|
38 | 38 | |
|
|
39 | 39 | create_table "descriptions", :force => true do |t| |
|
|
40 | 40 | t.text "body" |
|
|
41 | 41 | t.boolean "markdowned" |
|
|
42 | 42 | t.datetime "created_at" |
|
|
43 | 43 | t.datetime "updated_at" |
|
|
44 | 44 | end |
|
|
45 | 45 | |
|
|
46 | 46 | create_table "grader_processes", :force => true do |t| |
|
|
47 | 47 | t.string "host", :limit => 20 |
|
|
48 | 48 | t.integer "pid" |
|
|
49 | 49 | t.string "mode" |
|
|
50 | 50 | t.boolean "active" |
|
|
51 | 51 | t.datetime "created_at" |
|
|
52 | 52 | t.datetime "updated_at" |
|
|
53 | 53 | t.integer "task_id" |
|
|
54 | 54 | t.string "task_type" |
|
|
55 | 55 | t.boolean "terminated" |
|
|
56 | 56 | end |
|
|
57 | 57 | |
|
|
58 | 58 | add_index "grader_processes", ["host", "pid"], :name => "index_grader_processes_on_ip_and_pid" |
|
|
59 | 59 | |
|
|
60 | 60 | create_table "languages", :force => true do |t| |
|
|
61 | 61 | t.string "name", :limit => 10 |
|
|
62 | 62 | t.string "pretty_name" |
|
|
63 | 63 | t.string "ext", :limit => 10 |
|
|
64 | 64 | t.string "common_ext" |
|
|
65 | 65 | end |
|
|
66 | 66 | |
|
|
67 | 67 | create_table "messages", :force => true do |t| |
|
|
68 | 68 | t.integer "sender_id" |
|
|
69 | 69 | t.integer "receiver_id" |
|
|
70 | 70 | t.integer "replying_message_id" |
|
|
71 | 71 | t.text "body" |
|
|
72 | 72 | t.boolean "replied" |
|
|
73 | 73 | t.datetime "created_at" |
|
|
74 | 74 | t.datetime "updated_at" |
|
|
75 | 75 | end |
|
|
76 | 76 | |
|
|
77 | 77 | create_table "problems", :force => true do |t| |
|
|
78 | 78 | t.string "name", :limit => 30 |
|
|
79 | 79 | t.string "full_name" |
|
|
80 | 80 | t.integer "full_score" |
|
|
81 | 81 | t.date "date_added" |
|
|
82 | 82 | t.boolean "available" |
|
|
83 | 83 | t.string "url" |
|
|
84 | 84 | t.integer "description_id" |
|
|
85 | 85 | t.boolean "test_allowed" |
|
|
86 | 86 | t.boolean "output_only" |
|
|
87 | 87 | end |
|
|
88 | 88 | |
|
|
89 | 89 | create_table "rights", :force => true do |t| |
|
|
90 | 90 | t.string "name" |
|
|
91 | 91 | t.string "controller" |
|
|
92 | 92 | t.string "action" |
|
|
93 | 93 | end |
|
|
94 | 94 | |
|
|
95 | 95 | create_table "rights_roles", :id => false, :force => true do |t| |
|
|
96 | 96 | t.integer "right_id" |
|
|
97 | 97 | t.integer "role_id" |
|
|
98 | 98 | end |
|
|
99 | 99 | |
|
|
100 | 100 | add_index "rights_roles", ["role_id"], :name => "index_rights_roles_on_role_id" |
|
|
101 | 101 | |
|
|
102 | 102 | create_table "roles", :force => true do |t| |
|
|
103 | 103 | t.string "name" |
|
|
104 | 104 | end |
|
|
105 | 105 | |
|
|
106 | 106 | create_table "roles_users", :id => false, :force => true do |t| |
|
|
107 | 107 | t.integer "role_id" |
|
|
108 | 108 | t.integer "user_id" |
|
|
109 | 109 | end |
|
|
110 | 110 | |
|
|
111 | 111 | add_index "roles_users", ["user_id"], :name => "index_roles_users_on_user_id" |
|
|
112 | 112 | |
|
|
113 | 113 | create_table "sessions", :force => true do |t| |
|
|
114 | 114 | t.string "session_id" |
|
|
115 | 115 | t.text "data" |
|
|
116 | 116 | t.datetime "updated_at" |
|
|
117 | 117 | end |
|
|
118 | 118 | |
|
|
119 | 119 | add_index "sessions", ["session_id"], :name => "index_sessions_on_session_id" |
|
|
120 | 120 | add_index "sessions", ["updated_at"], :name => "index_sessions_on_updated_at" |
|
|
121 | 121 | |
|
|
122 | 122 | create_table "sites", :force => true do |t| |
|
|
123 | 123 | t.string "name" |
|
|
124 | 124 | t.boolean "started" |
|
|
125 | 125 | t.datetime "start_time" |
|
|
126 | 126 | t.datetime "created_at" |
|
|
127 | 127 | t.datetime "updated_at" |
|
|
128 | 128 | t.integer "country_id" |
|
|
129 | 129 | t.string "password" |
|
|
130 | 130 | end |
|
|
131 | 131 | |
|
|
132 | 132 | create_table "submissions", :force => true do |t| |
|
|
133 | 133 | t.integer "user_id" |
|
|
134 | 134 | t.integer "problem_id" |
|
|
135 | 135 | t.integer "language_id" |
|
|
136 | 136 | t.text "source" |
|
|
137 | 137 | t.binary "binary" |
|
|
138 | 138 | t.datetime "submitted_at" |
|
|
139 | 139 | t.datetime "compiled_at" |
|
|
140 | 140 | t.text "compiler_message" |
|
|
141 | 141 | t.datetime "graded_at" |
|
|
142 | 142 | t.integer "points" |
|
|
143 | 143 | t.text "grader_comment" |
|
|
144 | 144 | t.integer "number" |
|
|
145 | 145 | t.string "source_filename" |
|
|
146 | 146 | end |
|
|
147 | 147 | |
|
|
148 | 148 | add_index "submissions", ["user_id", "problem_id", "number"], :name => "index_submissions_on_user_id_and_problem_id_and_number", :unique => true |
|
|
149 | 149 | add_index "submissions", ["user_id", "problem_id"], :name => "index_submissions_on_user_id_and_problem_id" |
|
|
150 | 150 | |
|
|
151 | 151 | create_table "tasks", :force => true do |t| |
|
|
152 | 152 | t.integer "submission_id" |
|
|
153 | 153 | t.datetime "created_at" |
|
|
154 | 154 | t.integer "status" |
|
|
155 | 155 | t.datetime "updated_at" |
|
|
156 | 156 | end |
|
|
157 | 157 | |
|
|
158 | + create_table "test_pair_assignments", :force => true do |t| | |
|
|
159 | + t.integer "user_id" | |
|
|
160 | + t.integer "problem_id" | |
|
|
161 | + t.integer "test_pair_id" | |
|
|
162 | + t.integer "test_pair_number" | |
|
|
163 | + t.integer "request_number" | |
|
|
164 | + t.datetime "created_at" | |
|
|
165 | + t.datetime "updated_at" | |
|
|
166 | + t.boolean "submitted" | |
|
|
167 | + end | |
|
|
168 | + | |
|
|
158 | 169 | create_table "test_pairs", :force => true do |t| |
|
|
159 | 170 | t.integer "problem_id" |
|
|
160 | 171 | t.text "input" |
|
|
161 | 172 | t.text "solution" |
|
|
162 | 173 | t.datetime "created_at" |
|
|
163 | 174 | t.datetime "updated_at" |
|
|
175 | + t.integer "number" | |
|
|
164 | 176 | end |
|
|
165 | 177 | |
|
|
166 | 178 | create_table "test_requests", :force => true do |t| |
|
|
167 | 179 | t.integer "user_id" |
|
|
168 | 180 | t.integer "problem_id" |
|
|
169 | 181 | t.integer "submission_id" |
|
|
170 | 182 | t.string "input_file_name" |
|
|
171 | 183 | t.string "output_file_name" |
|
|
172 | 184 | t.string "running_stat" |
|
|
173 | 185 | t.integer "status" |
|
|
174 | 186 | t.datetime "updated_at" |
|
|
175 | 187 | t.datetime "submitted_at" |
|
|
176 | 188 | t.datetime "compiled_at" |
|
|
177 | 189 | t.text "compiler_message" |
|
|
178 | 190 | t.datetime "graded_at" |
|
|
179 | 191 | t.string "grader_comment" |
|
|
180 | 192 | t.datetime "created_at" |
|
|
181 | 193 | t.float "running_time" |
|
|
182 | 194 | t.string "exit_status" |
|
|
183 | 195 | t.integer "memory_usage" |
|
|
184 | 196 | end |
|
|
185 | 197 | |
|
|
186 | 198 | add_index "test_requests", ["user_id", "problem_id"], :name => "index_test_requests_on_user_id_and_problem_id" |
|
|
187 | 199 | |
|
|
188 | 200 | create_table "users", :force => true do |t| |
|
|
189 | 201 | t.string "login", :limit => 50 |
|
|
190 | 202 | t.string "full_name" |
|
|
191 | 203 | t.string "hashed_password" |
|
|
192 | 204 | t.string "salt", :limit => 5 |
|
|
193 | 205 | t.string "alias" |
|
|
194 | 206 | t.string "email" |
|
|
195 | 207 | t.integer "site_id" |
|
|
196 | 208 | t.integer "country_id" |
|
|
197 | 209 | t.boolean "activated", :default => false |
|
|
198 | 210 | t.datetime "created_at" |
|
|
199 | 211 | t.datetime "updated_at" |
|
|
200 | 212 | end |
|
|
201 | 213 | |
|
|
202 | 214 | add_index "users", ["login"], :name => "index_users_on_login", :unique => true |
|
|
203 | 215 | |
|
|
204 | 216 | end |
| @@ -1,134 +1,137 | |||
|
|
1 | 1 | require 'tmpdir' |
|
|
2 | 2 | |
|
|
3 | 3 | class TestdataImporter |
|
|
4 | 4 | |
|
|
5 | 5 | attr :log_msg |
|
|
6 | 6 | |
|
|
7 | 7 | def initialize(problem) |
|
|
8 | 8 | @problem = problem |
|
|
9 | 9 | end |
|
|
10 | 10 | |
|
|
11 | 11 | def import_from_file(tempfile, |
|
|
12 | 12 | time_limit, |
|
|
13 | 13 | memory_limit, |
|
|
14 | 14 | import_to_db=false) |
|
|
15 | 15 | |
|
|
16 | 16 | dirname = extract(tempfile) |
|
|
17 | 17 | return false if not dirname |
|
|
18 | 18 | if not import_to_db |
|
|
19 | 19 | @log_msg = GraderScript.call_import_problem(@problem.name, |
|
|
20 | 20 | dirname, |
|
|
21 | 21 | time_limit, |
|
|
22 | 22 | memory_limit) |
|
|
23 | 23 | else |
|
|
24 | 24 | # Import test data to test pairs. |
|
|
25 | 25 | |
|
|
26 | 26 | @problem.test_pairs.clear |
|
|
27 | 27 | if import_test_pairs(dirname) |
|
|
28 | 28 | test_pair_count = TestPair.count :conditions => "problem_id = #{@problem.id}" |
|
|
29 | 29 | @log_msg = "Importing test pair successful. (#{test_pair_count} test pairs imported)" |
|
|
30 | 30 | else |
|
|
31 | 31 | @log_msg = "Importing test pair failed. (0 test pairs imported)" |
|
|
32 | 32 | end |
|
|
33 | 33 | end |
|
|
34 | 34 | |
|
|
35 | 35 | @log_msg << import_problem_description(dirname) |
|
|
36 | 36 | |
|
|
37 | 37 | return true |
|
|
38 | 38 | end |
|
|
39 | 39 | |
|
|
40 | 40 | protected |
|
|
41 | 41 | |
|
|
42 | 42 | def self.long_ext(filename) |
|
|
43 | 43 | i = filename.index('.') |
|
|
44 | 44 | len = filename.length |
|
|
45 | 45 | return filename.slice(i..len) |
|
|
46 | 46 | end |
|
|
47 | 47 | |
|
|
48 | 48 | def extract(tempfile) |
|
|
49 | 49 | testdata_filename = save_testdata_file(tempfile) |
|
|
50 | 50 | ext = TestdataImporter.long_ext(tempfile.original_filename) |
|
|
51 | 51 | |
|
|
52 | 52 | extract_dir = File.join(GraderScript.raw_dir, @problem.name) |
|
|
53 | 53 | begin |
|
|
54 | 54 | Dir.mkdir extract_dir |
|
|
55 | 55 | rescue Errno::EEXIST |
|
|
56 | 56 | end |
|
|
57 | 57 | |
|
|
58 | 58 | if ext=='.tar.gz' or ext=='.tgz' |
|
|
59 | 59 | cmd = "tar -zxvf #{testdata_filename} -C #{extract_dir}" |
|
|
60 | 60 | elsif ext=='.tar' |
|
|
61 | 61 | cmd = "tar -xvf #{testdata_filename} -C #{extract_dir}" |
|
|
62 | 62 | elsif ext=='.zip' |
|
|
63 | 63 | cmd = "unzip -o #{testdata_filename} -d #{extract_dir}" |
|
|
64 | 64 | else |
|
|
65 | 65 | return nil |
|
|
66 | 66 | end |
|
|
67 | 67 | |
|
|
68 | 68 | system(cmd) |
|
|
69 | 69 | |
|
|
70 | 70 | files = Dir["#{extract_dir}/**/*1*.in"] |
|
|
71 | 71 | return nil if files.length==0 |
|
|
72 | 72 | |
|
|
73 | 73 | return File.dirname(files[0]) |
|
|
74 | 74 | end |
|
|
75 | 75 | |
|
|
76 | 76 | def save_testdata_file(tempfile) |
|
|
77 | 77 | ext = TestdataImporter.long_ext(tempfile.original_filename) |
|
|
78 | 78 | testdata_filename = File.join(Dir.tmpdir,"#{@problem.name}#{ext}") |
|
|
79 | 79 | |
|
|
80 | 80 | return nil if tempfile=="" |
|
|
81 | 81 | |
|
|
82 | 82 | if tempfile.instance_of?(Tempfile) |
|
|
83 | 83 | tempfile.close |
|
|
84 | 84 | FileUtils.move(tempfile.path,testdata_filename) |
|
|
85 | 85 | else |
|
|
86 | 86 | File.open(testdata_filename, "wb") do |f| |
|
|
87 | 87 | f.write(tempfile.read) |
|
|
88 | 88 | end |
|
|
89 | 89 | end |
|
|
90 | 90 | |
|
|
91 | 91 | return testdata_filename |
|
|
92 | 92 | end |
|
|
93 | 93 | |
|
|
94 | 94 | def import_test_pairs(dirname) |
|
|
95 | 95 | test_num = 1 |
|
|
96 | 96 | while FileTest.exists? "#{dirname}/#{test_num}.in" |
|
|
97 | 97 | in_filename = "#{dirname}/#{test_num}.in" |
|
|
98 | 98 | sol_filename = "#{dirname}/#{test_num}.sol" |
|
|
99 | 99 | |
|
|
100 | 100 | break if not FileTest.exists? sol_filename |
|
|
101 | 101 | |
|
|
102 | + puts "#{dirname}" | |
|
|
103 | + | |
|
|
102 | 104 | test_pair = TestPair.new(:input => open(in_filename).read, |
|
|
103 | 105 | :solution => open(sol_filename).read, |
|
|
106 | + :number => test_num, | |
|
|
104 | 107 | :problem => @problem) |
|
|
105 | 108 | break if not test_pair.save |
|
|
106 | 109 | |
|
|
107 | 110 | test_num += 1 |
|
|
108 | 111 | end |
|
|
109 | 112 | return test_num > 1 |
|
|
110 | 113 | end |
|
|
111 | 114 | |
|
|
112 | 115 | def import_problem_description(dirname) |
|
|
113 | 116 | html_files = Dir["#{dirname}/*.html"] |
|
|
114 | 117 | markdown_files = Dir["#{dirname}/*.md"] + Dir["#{dirname}/*.markdown"] |
|
|
115 | 118 | if (html_files.length != 0) or (markdown_files.length != 0) |
|
|
116 | 119 | description = @problem.description || Description.new |
|
|
117 | 120 | |
|
|
118 | 121 | if html_files.length != 0 |
|
|
119 | 122 | filename = html_files[0] |
|
|
120 | 123 | description.markdowned = false |
|
|
121 | 124 | else |
|
|
122 | 125 | filename = markdown_files[0] |
|
|
123 | 126 | description.markdowned = true |
|
|
124 | 127 | end |
|
|
125 | 128 | |
|
|
126 | 129 | description.body = open(filename).read |
|
|
127 | 130 | description.save |
|
|
128 | 131 | @problem.description = description |
|
|
129 | 132 | @problem.save |
|
|
130 | 133 | return "\nProblem description imported from #{filename}." |
|
|
131 | 134 | end |
|
|
132 | 135 | end |
|
|
133 | 136 | |
|
|
134 | 137 | end |
You need to be logged in to leave comments.
Login now