cafe-grader-web

Commit r347:6d2339b98fac public

parent | child
Description:
update errors.add_to_base("x") to Rails 3 errors.add(:base,"x")
Commit status:
[Not Reviewed]
References:
default
Diff options:
Raw Diff | Patch Diff | Download Diff | Ignore whitespace | Increase context
Comments:
0 Commit comments 0 Inline Comments
Unresolved TODOs:
There are no unresolved TODOs
Side by Side Unified
Expand All Files Collapse All Files Wide Mode Diff
Add another comment
Browse Files

r347:6d2339b98fac - - 6 files changed: 12 inserted, 12 deleted

Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,264 +1,264
1 1 class MainController < ApplicationController
2 2
3 3 before_filter :authenticate, :except => [:index, :login]
4 4 before_filter :check_viewability, :except => [:index, :login]
5 5
6 6 append_before_filter :confirm_and_update_start_time,
7 7 :except => [:index,
8 8 :login,
9 9 :confirm_contest_start]
10 10
11 11 # to prevent log in box to be shown when user logged out of the
12 12 # system only in some tab
13 13 prepend_before_filter :reject_announcement_refresh_when_logged_out,
14 14 :only => [:announcements]
15 15
16 16 # COMMENTED OUT: filter in each action instead
17 17 # before_filter :verify_time_limit, :only => [:submit]
18 18
19 19 verify :method => :post, :only => [:submit],
20 20 :redirect_to => { :action => :index }
21 21
22 22 # COMMENT OUT: only need when having high load
23 23 # caches_action :index, :login
24 24
25 25 # NOTE: This method is not actually needed, 'config/routes.rb' has
26 26 # assigned action login as a default action.
27 27 def index
28 28 redirect_to :action => 'login'
29 29 end
30 30
31 31 def login
32 32 saved_notice = flash[:notice]
33 33 reset_session
34 34 flash.now[:notice] = saved_notice
35 35
36 36 # EXPERIMENT:
37 37 # Hide login if in single user mode and the url does not
38 38 # explicitly specify /login
39 39 #
40 40 # logger.info "PATH: #{request.path}"
41 41 # if GraderConfiguration['system.single_user_mode'] and
42 42 # request.path!='/main/login'
43 43 # @hidelogin = true
44 44 # end
45 45
46 46 @announcements = Announcement.find_for_frontpage
47 47 render :action => 'login', :layout => 'empty'
48 48 end
49 49
50 50 def list
51 51 prepare_list_information
52 52 end
53 53
54 54 def help
55 55 @user = User.find(session[:user_id])
56 56 end
57 57
58 58 def submit
59 59 user = User.find(session[:user_id])
60 60
61 61 @submission = Submission.new
62 62 @submission.problem_id = params[:submission][:problem_id]
63 63 @submission.user = user
64 64 @submission.language_id = 0
65 65 if (params['file']) and (params['file']!='')
66 66 @submission.source = params['file'].read
67 67 @submission.source_filename = params['file'].original_filename
68 68 end
69 69 @submission.submitted_at = Time.new.gmtime
70 70
71 71 if GraderConfiguration.time_limit_mode? and user.contest_finished?
72 - @submission.errors.add_to_base "The contest is over."
72 + @submission.errors.add(:base,"The contest is over.")
73 73 prepare_list_information
74 74 render :action => 'list' and return
75 75 end
76 76
77 77 if @submission.valid?
78 78 if @submission.save == false
79 79 flash[:notice] = 'Error saving your submission'
80 80 elsif Task.create(:submission_id => @submission.id,
81 81 :status => Task::STATUS_INQUEUE) == false
82 82 flash[:notice] = 'Error adding your submission to task queue'
83 83 end
84 84 else
85 85 prepare_list_information
86 86 render :action => 'list' and return
87 87 end
88 88 redirect_to :action => 'list'
89 89 end
90 90
91 91 def source
92 92 submission = Submission.find(params[:id])
93 93 if ((submission.user_id == session[:user_id]) and
94 94 (submission.problem != nil) and
95 95 (submission.problem.available))
96 96 send_data(submission.source,
97 97 {:filename => submission.download_filename,
98 98 :type => 'text/plain'})
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 compiler_msg
106 106 @submission = Submission.find(params[:id])
107 107 if @submission.user_id == session[:user_id]
108 108 render :action => 'compiler_msg', :layout => 'empty'
109 109 else
110 110 flash[:notice] = 'Error viewing source'
111 111 redirect_to :action => 'list'
112 112 end
113 113 end
114 114
115 115 def submission
116 116 @user = User.find(session[:user_id])
117 117 @problems = @user.available_problems
118 118 if params[:id]==nil
119 119 @problem = nil
120 120 @submissions = nil
121 121 else
122 122 @problem = Problem.find_by_name(params[:id])
123 123 if not @problem.available
124 124 redirect_to :action => 'list'
125 125 flash[:notice] = 'Error: submissions for that problem are not viewable.'
126 126 return
127 127 end
128 128 @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id)
129 129 end
130 130 end
131 131
132 132 def result
133 133 if !GraderConfiguration.show_grading_result
134 134 redirect_to :action => 'list' and return
135 135 end
136 136 @user = User.find(session[:user_id])
137 137 @submission = Submission.find(params[:id])
138 138 if @submission.user!=@user
139 139 flash[:notice] = 'You are not allowed to view result of other users.'
140 140 redirect_to :action => 'list' and return
141 141 end
142 142 prepare_grading_result(@submission)
143 143 end
144 144
145 145 def load_output
146 146 if !GraderConfiguration.show_grading_result or params[:num]==nil
147 147 redirect_to :action => 'list' and return
148 148 end
149 149 @user = User.find(session[:user_id])
150 150 @submission = Submission.find(params[:id])
151 151 if @submission.user!=@user
152 152 flash[:notice] = 'You are not allowed to view result of other users.'
153 153 redirect_to :action => 'list' and return
154 154 end
155 155 case_num = params[:num].to_i
156 156 out_filename = output_filename(@user.login,
157 157 @submission.problem.name,
158 158 @submission.id,
159 159 case_num)
160 160 if !FileTest.exists?(out_filename)
161 161 flash[:notice] = 'Output not found.'
162 162 redirect_to :action => 'list' and return
163 163 end
164 164
165 165 if defined?(USE_APACHE_XSENDFILE) and USE_APACHE_XSENDFILE
166 166 response.headers['Content-Type'] = "application/force-download"
167 167 response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
168 168 response.headers["X-Sendfile"] = out_filename
169 169 response.headers['Content-length'] = File.size(out_filename)
170 170 render :nothing => true
171 171 else
172 172 send_file out_filename, :stream => false, :filename => "output-#{case_num}.txt", :type => "text/plain"
173 173 end
174 174 end
175 175
176 176 def error
177 177 @user = User.find(session[:user_id])
178 178 end
179 179
180 180 # announcement refreshing and hiding methods
181 181
182 182 def announcements
183 183 if params.has_key? 'recent'
184 184 prepare_announcements(params[:recent])
185 185 else
186 186 prepare_announcements
187 187 end
188 188 render(:partial => 'announcement',
189 189 :collection => @announcements,
190 190 :locals => {:announcement_effect => true})
191 191 end
192 192
193 193 def confirm_contest_start
194 194 user = User.find(session[:user_id])
195 195 if request.method == :post
196 196 user.update_start_time
197 197 redirect_to :action => 'list'
198 198 else
199 199 @contests = user.contests
200 200 @user = user
201 201 end
202 202 end
203 203
204 204 protected
205 205
206 206 def prepare_announcements(recent=nil)
207 207 if GraderConfiguration.show_tasks_to?(@user)
208 208 @announcements = Announcement.find_published(true)
209 209 else
210 210 @announcements = Announcement.find_published
211 211 end
212 212 if recent!=nil
213 213 recent_id = recent.to_i
214 214 @announcements = @announcements.find_all { |a| a.id > recent_id }
215 215 end
216 216 end
217 217
218 218 def prepare_list_information
219 219 @user = User.find(session[:user_id])
220 220 if not GraderConfiguration.multicontests?
221 221 @problems = @user.available_problems
222 222 else
223 223 @contest_problems = @user.available_problems_group_by_contests
224 224 @problems = @user.available_problems
225 225 end
226 226 @prob_submissions = {}
227 227 @problems.each do |p|
228 228 sub = Submission.find_last_by_user_and_problem(@user.id,p.id)
229 229 if sub!=nil
230 230 @prob_submissions[p.id] = { :count => sub.number, :submission => sub }
231 231 else
232 232 @prob_submissions[p.id] = { :count => 0, :submission => nil }
233 233 end
234 234 end
235 235 prepare_announcements
236 236 end
237 237
238 238 def check_viewability
239 239 @user = User.find(session[:user_id])
240 240 if (!GraderConfiguration.show_tasks_to?(@user)) and
241 241 ((action_name=='submission') or (action_name=='submit'))
242 242 redirect_to :action => 'list' and return
243 243 end
244 244 end
245 245
246 246 def prepare_grading_result(submission)
247 247 if GraderConfiguration.task_grading_info.has_key? submission.problem.name
248 248 grading_info = GraderConfiguration.task_grading_info[submission.problem.name]
249 249 else
250 250 # guess task info from problem.full_score
251 251 cases = submission.problem.full_score / 10
252 252 grading_info = {
253 253 'testruns' => cases,
254 254 'testcases' => cases
255 255 }
256 256 end
257 257 @test_runs = []
258 258 if grading_info['testruns'].is_a? Integer
259 259 trun_count = grading_info['testruns']
260 260 trun_count.times do |i|
261 261 @test_runs << [ read_grading_result(@user.login,
262 262 submission.problem.name,
263 263 submission.id,
264 264 i+1) ]
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,118 +1,118
1 1 class TestController < ApplicationController
2 2
3 3 before_filter :authenticate, :check_viewability
4 4
5 5 #
6 6 # COMMENT OUT: filter in each action instead
7 7 #
8 8 # before_filter :verify_time_limit, :only => [:submit]
9 9
10 10 verify :method => :post, :only => [:submit],
11 11 :redirect_to => { :action => :index }
12 12
13 13 def index
14 14 prepare_index_information
15 15 end
16 16
17 17 def submit
18 18 @user = User.find(session[:user_id])
19 19
20 20 @submitted_test_request = TestRequest.new_from_form_params(@user,params[:test_request])
21 21
22 22 if ! @submitted_test_request.errors.empty?
23 23 prepare_index_information
24 24 render :action => 'index' and return
25 25 end
26 26
27 27 if GraderConfiguration.time_limit_mode?
28 28 if @user.contest_finished?
29 - @submitted_test_request.errors.add_to_base('Contest is over.')
29 + @submitted_test_request.errors.add(:base,'Contest is over.')
30 30 prepare_index_information
31 31 render :action => 'index' and return
32 32 end
33 33
34 34 if !GraderConfiguration.allow_test_request(@user)
35 35 prepare_index_information
36 36 flash[:notice] = 'Test request is not allowed during the last 30 minutes'
37 37 redirect_to :action => 'index' and return
38 38 end
39 39 end
40 40
41 41 if @submitted_test_request.save
42 42 redirect_to :action => 'index'
43 43 else
44 44 prepare_index_information
45 45 render :action => 'index'
46 46 end
47 47 end
48 48
49 49 def read
50 50 user = User.find(session[:user_id])
51 51 begin
52 52 test_request = TestRequest.find(params[:id])
53 53 rescue
54 54 test_request = nil
55 55 end
56 56 if test_request==nil or test_request.user_id != user.id
57 57 flash[:notice] = 'Invalid output'
58 58 redirect_to :action => 'index'
59 59 return
60 60 end
61 61 if test_request.output_file_name!=nil
62 62 data = File.open(test_request.output_file_name).read(2048)
63 63 if data==nil
64 64 data=""
65 65 end
66 66 send_data(data,
67 67 {:filename => 'output.txt',
68 68 :type => 'text/plain'})
69 69 return
70 70 end
71 71 redirect_to :action => 'index'
72 72 end
73 73
74 74 def result
75 75 @user = User.find(session[:user_id])
76 76 begin
77 77 @test_request = TestRequest.find(params[:id])
78 78 rescue
79 79 @test_request = nil
80 80 end
81 81 if @test_request==nil or @test_request.user_id != @user.id
82 82 flash[:notice] = 'Invalid request'
83 83 redirect_to :action => 'index'
84 84 return
85 85 end
86 86 end
87 87
88 88 protected
89 89
90 90 def prepare_index_information
91 91 @user = User.find(session[:user_id])
92 92 @submissions = Submission.find_last_for_all_available_problems(@user.id)
93 93 all_problems = @submissions.collect { |submission| submission.problem }
94 94 @problems = []
95 95 all_problems.each do |problem|
96 96 if problem.test_allowed
97 97 @problems << problem
98 98 end
99 99 end
100 100 @test_requests = []
101 101 @user.test_requests.each do |ts|
102 102 if ts.problem and ts.problem.available
103 103 @test_requests << ts
104 104 end
105 105 end
106 106 end
107 107
108 108 def check_viewability
109 109 user = User.find(session[:user_id])
110 110 if !GraderConfiguration.show_tasks_to?(user)
111 111 redirect_to :controller => 'main', :action => 'list'
112 112 end
113 113 if (!GraderConfiguration.show_submitbox_to?(user)) and (action_name=='submit')
114 114 redirect_to :controller => 'test', :action => 'index'
115 115 end
116 116 end
117 117
118 118 end
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,156 +1,156
1 1 require 'net/smtp'
2 2
3 3 class UsersController < ApplicationController
4 4
5 5 include MailHelperMethods
6 6
7 7 before_filter :authenticate, :except => [:new,
8 8 :register,
9 9 :confirm,
10 10 :forget,
11 11 :retrieve_password]
12 12
13 13 before_filter :verify_online_registration, :only => [:new,
14 14 :register,
15 15 :forget,
16 16 :retrieve_password]
17 17
18 18 verify :method => :post, :only => [:chg_passwd],
19 19 :redirect_to => { :action => :index }
20 20
21 21 #in_place_edit_for :user, :alias_for_editing
22 22 #in_place_edit_for :user, :email_for_editing
23 23
24 24 def index
25 25 if !GraderConfiguration['system.user_setting_enabled']
26 26 redirect_to :controller => 'main', :action => 'list'
27 27 else
28 28 @user = User.find(session[:user_id])
29 29 end
30 30 end
31 31
32 32 def chg_passwd
33 33 user = User.find(session[:user_id])
34 34 user.password = params[:passwd]
35 35 user.password_confirmation = params[:passwd_verify]
36 36 if user.save
37 37 flash[:notice] = 'password changed'
38 38 else
39 39 flash[:notice] = 'Error: password changing failed'
40 40 end
41 41 redirect_to :action => 'index'
42 42 end
43 43
44 44 def new
45 45 @user = User.new
46 46 render :action => 'new', :layout => 'empty'
47 47 end
48 48
49 49 def register
50 50 if(params[:cancel])
51 51 redirect_to :controller => 'main', :action => 'login'
52 52 return
53 53 end
54 54 @user = User.new(params[:user])
55 55 @user.password_confirmation = @user.password = User.random_password
56 56 @user.activated = false
57 57 if (@user.valid?) and (@user.save)
58 58 if send_confirmation_email(@user)
59 59 render :action => 'new_splash', :layout => 'empty'
60 60 else
61 61 @admin_email = GraderConfiguration['system.admin_email']
62 62 render :action => 'email_error', :layout => 'empty'
63 63 end
64 64 else
65 - @user.errors.add_to_base("Email cannot be blank") if @user.email==''
65 + @user.errors.add(:base,"Email cannot be blank") if @user.email==''
66 66 render :action => 'new', :layout => 'empty'
67 67 end
68 68 end
69 69
70 70 def confirm
71 71 login = params[:login]
72 72 key = params[:activation]
73 73 @user = User.find_by_login(login)
74 74 if (@user) and (@user.verify_activation_key(key))
75 75 if @user.valid? # check uniquenss of email
76 76 @user.activated = true
77 77 @user.save
78 78 @result = :successful
79 79 else
80 80 @result = :email_used
81 81 end
82 82 else
83 83 @result = :failed
84 84 end
85 85 render :action => 'confirm', :layout => 'empty'
86 86 end
87 87
88 88 def forget
89 89 render :action => 'forget', :layout => 'empty'
90 90 end
91 91
92 92 def retrieve_password
93 93 email = params[:email]
94 94 user = User.find_by_email(email)
95 95 if user
96 96 last_updated_time = user.updated_at || user.created_at || (Time.now.gmtime - 1.hour)
97 97 if last_updated_time > Time.now.gmtime - 5.minutes
98 98 flash[:notice] = 'The account has recently created or new password has recently been requested. Please wait for 5 minutes'
99 99 else
100 100 user.password = user.password_confirmation = User.random_password
101 101 user.save
102 102 send_new_password_email(user)
103 103 flash[:notice] = 'New password has been mailed to you.'
104 104 end
105 105 else
106 106 flash[:notice] = I18n.t 'registration.password_retrieval.no_email'
107 107 end
108 108 redirect_to :action => 'forget'
109 109 end
110 110
111 111 protected
112 112
113 113 def verify_online_registration
114 114 if !GraderConfiguration['system.online_registration']
115 115 redirect_to :controller => 'main', :action => 'login'
116 116 end
117 117 end
118 118
119 119 def send_confirmation_email(user)
120 120 contest_name = GraderConfiguration['contest.name']
121 121 activation_url = url_for(:action => 'confirm',
122 122 :login => user.login,
123 123 :activation => user.activation_key)
124 124 home_url = url_for(:controller => 'main', :action => 'index')
125 125 mail_subject = "[#{contest_name}] Confirmation"
126 126 mail_body = t('registration.email_body', {
127 127 :full_name => user.full_name,
128 128 :contest_name => contest_name,
129 129 :login => user.login,
130 130 :password => user.password,
131 131 :activation_url => activation_url,
132 132 :admin_email => admin_email
133 133 })
134 134
135 135 logger.info mail_body
136 136
137 137 send_mail(user.email, mail_subject, mail_body)
138 138 end
139 139
140 140 def send_new_password_email(user)
141 141 contest_name = GraderConfiguration['contest.name']
142 142 mail_subject = "[#{contest_name}] Password recovery"
143 143 mail_body = t('registration.password_retrieval.email_body', {
144 144 :full_name => user.full_name,
145 145 :contest_name => contest_name,
146 146 :login => user.login,
147 147 :password => user.password,
148 148 :admin_email => admin_email
149 149 })
150 150
151 151 logger.info mail_body
152 152
153 153 send_mail(user.email, mail_subject, mail_body)
154 154 end
155 155
156 156 end
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,114 +1,114
1 1 class Problem < ActiveRecord::Base
2 2
3 3 belongs_to :description
4 4 has_and_belongs_to_many :contests, :uniq => true
5 5 has_many :test_pairs, :dependent => :delete_all
6 6
7 7 validates_presence_of :name
8 8 validates_format_of :name, :with => /^\w+$/
9 9 validates_presence_of :full_name
10 10
11 11 scope :available, :conditions => {:available => true}
12 12
13 13 DEFAULT_TIME_LIMIT = 1
14 14 DEFAULT_MEMORY_LIMIT = 32
15 15
16 16 def self.find_available_problems
17 17 Problem.available.all(:order => "date_added DESC")
18 18 end
19 19
20 20 def self.create_from_import_form_params(params, old_problem=nil)
21 21 org_problem = old_problem || Problem.new
22 22 import_params, problem = Problem.extract_params_and_check(params,
23 23 org_problem)
24 24
25 25 if !problem.errors.empty?
26 26 return problem, 'Error importing'
27 27 end
28 28
29 29 problem.full_score = 100
30 30 problem.date_added = Time.new
31 31 problem.test_allowed = true
32 32 problem.output_only = false
33 33 problem.available = false
34 34
35 35 if not problem.save
36 36 return problem, 'Error importing'
37 37 end
38 38
39 39 import_to_db = params.has_key? :import_to_db
40 40
41 41 importer = TestdataImporter.new(problem)
42 42
43 43 if not importer.import_from_file(import_params[:file],
44 44 import_params[:time_limit],
45 45 import_params[:memory_limit],
46 46 import_to_db)
47 - problem.errors.add_to_base('Import error.')
47 + problem.errors.add(:base,'Import error.')
48 48 end
49 49
50 50 return problem, importer.log_msg
51 51 end
52 52
53 53 def self.download_file_basedir
54 54 return "#{Rails.root}/data/tasks"
55 55 end
56 56
57 57 protected
58 58
59 59 def self.to_i_or_default(st, default)
60 60 if st!=''
61 61 result = st.to_i
62 62 end
63 63 result ||= default
64 64 end
65 65
66 66 def self.to_f_or_default(st, default)
67 67 if st!=''
68 68 result = st.to_f
69 69 end
70 70 result ||= default
71 71 end
72 72
73 73 def self.extract_params_and_check(params, problem)
74 74 time_limit = Problem.to_f_or_default(params[:time_limit],
75 75 DEFAULT_TIME_LIMIT)
76 76 memory_limit = Problem.to_i_or_default(params[:memory_limit],
77 77 DEFAULT_MEMORY_LIMIT)
78 78
79 79 if time_limit<=0 or time_limit >60
80 - problem.errors.add_to_base('Time limit out of range.')
80 + problem.errors.add(:base,'Time limit out of range.')
81 81 end
82 82
83 83 if memory_limit==0 and params[:memory_limit]!='0'
84 - problem.errors.add_to_base('Memory limit format errors.')
84 + problem.errors.add(:base,'Memory limit format errors.')
85 85 elsif memory_limit<=0 or memory_limit >512
86 - problem.errors.add_to_base('Memory limit out of range.')
86 + problem.errors.add(:base,'Memory limit out of range.')
87 87 end
88 88
89 89 if params[:file]==nil or params[:file]==''
90 - problem.errors.add_to_base('No testdata file.')
90 + problem.errors.add(:base,'No testdata file.')
91 91 end
92 92
93 93 file = params[:file]
94 94
95 95 if !problem.errors.empty?
96 96 return nil, problem
97 97 end
98 98
99 99 problem.name = params[:name]
100 100 if params[:full_name]!=''
101 101 problem.full_name = params[:full_name]
102 102 else
103 103 problem.full_name = params[:name]
104 104 end
105 105
106 106 return [{
107 107 :time_limit => time_limit,
108 108 :memory_limit => memory_limit,
109 109 :file => file
110 110 },
111 111 problem]
112 112 end
113 113
114 114 end
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,157 +1,157
1 1 #
2 2 # A TestRequest is a composition of submission with user's testdata.
3 3 #
4 4 # Note about TestRequest#problem: Usually, A TestRequest has to be
5 5 # associated with a problem, so that execution environment can be
6 6 # determined. However, to be more flexible, we have to ensure that
7 7 # it works as well with problem=nil. In this case, we shall provide
8 8 # a "default" execution environment for it. This can be done
9 9 # seamlessly by using TestRequest#problem_name or
10 10 # TestRequest#name_of(problem) when retrieving the name of the
11 11 # problem: #name_of would return problem.name when problem!=nil and
12 12 # it would return "default" when problem=nil, #problem_name just
13 13 # call #name_of.
14 14 #
15 15
16 16 require 'fileutils'
17 17
18 18 class TestRequest < Task
19 19
20 20 set_table_name "test_requests"
21 21
22 22 belongs_to :user
23 23 belongs_to :problem
24 24 belongs_to :submission
25 25
26 26 validates_presence_of :submission
27 27 validate :must_have_valid_problem
28 28
29 29 def problem_name
30 30 TestRequest.name_of(self.problem)
31 31 end
32 32
33 33 def language
34 34 self.submission.language
35 35 end
36 36
37 37 def self.get_inqueue_and_change_status(status)
38 38 # since there will be only one grader grading TestRequest
39 39 # we do not need locking (hopefully)
40 40
41 41 test_request = TestRequest.find(:first,
42 42 :order => "created_at",
43 43 :conditions => {:status=> Task::STATUS_INQUEUE})
44 44 if test_request!=nil
45 45 test_request.status = status
46 46 test_request.save!
47 47 end
48 48
49 49 test_request
50 50 end
51 51
52 52 # interfacing with form
53 53 def self.new_from_form_params(user,params)
54 54 test_request = TestRequest.new
55 55 test_request.user = user
56 56 begin
57 57 problem = Problem.find(params[:problem_id])
58 58 rescue ActiveRecord::RecordNotFound
59 59 problem = nil
60 60 end
61 61 test_request.problem = problem
62 62 if problem!=nil
63 63 test_request.submission =
64 64 Submission.find_by_user_problem_number(user.id,
65 65 problem.id,
66 66 params[:submission_number])
67 67 else
68 68 test_request.submission = nil
69 69 end
70 70
71 71 # checks if the user submits any input file
72 72 if params[:input_file]==nil or params[:input_file]==""
73 - test_request.errors.add_to_base("No input submitted.")
73 + test_request.errors.add(:base,"No input submitted.")
74 74 test_request.input_file_name = nil
75 75 else
76 76 test_request.input_file_name = save_input_file(params[:input_file], user, problem)
77 77 if test_request.input_file_name == nil
78 - test_request.errors.add_to_base("No input submitted.")
78 + test_request.errors.adds(:base,"No input submitted.")
79 79 end
80 80 if params[:additional_file]!=nil and params[:additional_file]!=""
81 81 save_additional_file(params[:additional_file],
82 82 "#{test_request.input_file_name}.files")
83 83 end
84 84 end
85 85 test_request.submitted_at = Time.new.gmtime
86 86 test_request.status_inqueue
87 87 test_request
88 88 end
89 89
90 90 protected
91 91
92 92 def self.name_of(problem)
93 93 if problem!=nil
94 94 problem.name
95 95 else
96 96 "default"
97 97 end
98 98 end
99 99
100 100 def self.random_input_file_name(user,problem)
101 101 problem_name = TestRequest.name_of(problem)
102 102 begin
103 103 tmpname = TEST_REQUEST_INPUT_FILE_DIR + "/#{user.login}/#{problem_name}/#{rand(10000)}"
104 104 end while File.exists?(tmpname)
105 105 tmpname
106 106 end
107 107
108 108 def self.save_input_file(tempfile, user, problem)
109 109 new_file_name = random_input_file_name(user,problem)
110 110 dirname = File.dirname(new_file_name)
111 111 FileUtils.mkdir_p(File.dirname(new_file_name)) if !File.exists?(dirname)
112 112
113 113 # when the user did not submit any file
114 114 return nil if tempfile==""
115 115
116 116 if tempfile.instance_of?(Tempfile)
117 117 tempfile.close
118 118 FileUtils.move(tempfile.path,new_file_name)
119 119 else
120 120 File.open(new_file_name, "wb") do |f|
121 121 f.write(tempfile.read)
122 122 end
123 123 end
124 124 new_file_name
125 125 end
126 126
127 127 def self.save_additional_file(tempfile,dir)
128 128 new_file_name = "#{dir}/#{tempfile.original_filename}"
129 129 dirname = File.dirname(new_file_name)
130 130 FileUtils.mkdir_p(File.dirname(new_file_name)) if !File.exists?(dirname)
131 131
132 132 # when the user did not submit any file
133 133 return nil if tempfile==""
134 134
135 135 if tempfile.instance_of?(Tempfile)
136 136 tempfile.close
137 137 FileUtils.move(tempfile.path,new_file_name)
138 138 else
139 139 File.open(new_file_name, "wb") do |f|
140 140 f.write(tempfile.read)
141 141 end
142 142 end
143 143 new_file_name
144 144 end
145 145
146 146 #
147 147 # validations
148 148 #
149 149 def must_have_valid_problem
150 150 if problem==nil
151 151 errors.add('problem',"must be specified.")
152 152 elsif (!problem.available) and (self.new_record?)
153 153 errors.add('problem',"must be valid.")
154 154 end
155 155 end
156 156
157 157 end
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -109,215 +109,215
109 109 encrypt_new_password
110 110 end
111 111 Digest::SHA1.hexdigest(self.hashed_password)[0..7]
112 112 end
113 113
114 114 def verify_activation_key(key)
115 115 key == activation_key
116 116 end
117 117
118 118 def self.random_password(length=5)
119 119 chars = 'abcdefghjkmnopqrstuvwxyz'
120 120 password = ''
121 121 length.times { password << chars[rand(chars.length - 1)] }
122 122 password
123 123 end
124 124
125 125 def self.find_non_admin_with_prefix(prefix='')
126 126 users = User.find(:all)
127 127 return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
128 128 end
129 129
130 130 # Contest information
131 131
132 132 def self.find_users_with_no_contest()
133 133 users = User.find(:all)
134 134 return users.find_all { |u| u.contests.length == 0 }
135 135 end
136 136
137 137
138 138 def contest_time_left
139 139 if GraderConfiguration.contest_mode?
140 140 return nil if site==nil
141 141 return site.time_left
142 142 elsif GraderConfiguration.indv_contest_mode?
143 143 time_limit = GraderConfiguration.contest_time_limit
144 144 if time_limit == nil
145 145 return nil
146 146 end
147 147 if contest_stat==nil or contest_stat.started_at==nil
148 148 return (Time.now.gmtime + time_limit) - Time.now.gmtime
149 149 else
150 150 finish_time = contest_stat.started_at + time_limit
151 151 current_time = Time.now.gmtime
152 152 if current_time > finish_time
153 153 return 0
154 154 else
155 155 return finish_time - current_time
156 156 end
157 157 end
158 158 else
159 159 return nil
160 160 end
161 161 end
162 162
163 163 def contest_finished?
164 164 if GraderConfiguration.contest_mode?
165 165 return false if site==nil
166 166 return site.finished?
167 167 elsif GraderConfiguration.indv_contest_mode?
168 168 return false if self.contest_stat(true)==nil
169 169 return contest_time_left == 0
170 170 else
171 171 return false
172 172 end
173 173 end
174 174
175 175 def contest_started?
176 176 if GraderConfiguration.indv_contest_mode?
177 177 stat = self.contest_stat
178 178 return ((stat != nil) and (stat.started_at != nil))
179 179 elsif GraderConfiguration.contest_mode?
180 180 return true if site==nil
181 181 return site.started
182 182 else
183 183 return true
184 184 end
185 185 end
186 186
187 187 def update_start_time
188 188 stat = self.contest_stat
189 189 if stat == nil or stat.started_at == nil
190 190 stat ||= UserContestStat.new(:user => self)
191 191 stat.started_at = Time.now.gmtime
192 192 stat.save
193 193 end
194 194 end
195 195
196 196 def problem_in_user_contests?(problem)
197 197 problem_contests = problem.contests.all
198 198
199 199 if problem_contests.length == 0 # this is public contest
200 200 return true
201 201 end
202 202
203 203 contests.each do |contest|
204 204 if problem_contests.find {|c| c.id == contest.id }
205 205 return true
206 206 end
207 207 end
208 208 return false
209 209 end
210 210
211 211 def available_problems_group_by_contests
212 212 contest_problems = []
213 213 pin = {}
214 214 contests.enabled.each do |contest|
215 215 available_problems = contest.problems.available
216 216 contest_problems << {
217 217 :contest => contest,
218 218 :problems => available_problems
219 219 }
220 220 available_problems.each {|p| pin[p.id] = true}
221 221 end
222 222 other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
223 223 contest_problems << {
224 224 :contest => nil,
225 225 :problems => other_avaiable_problems
226 226 }
227 227 return contest_problems
228 228 end
229 229
230 230 def available_problems
231 231 if not GraderConfiguration.multicontests?
232 232 return Problem.find_available_problems
233 233 else
234 234 contest_problems = []
235 235 pin = {}
236 236 contests.enabled.each do |contest|
237 237 contest.problems.available.each do |problem|
238 238 if not pin.has_key? problem.id
239 239 contest_problems << problem
240 240 end
241 241 pin[problem.id] = true
242 242 end
243 243 end
244 244 other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
245 245 return contest_problems + other_avaiable_problems
246 246 end
247 247 end
248 248
249 249 def can_view_problem?(problem)
250 250 if not GraderConfiguration.multicontests?
251 251 return problem.available
252 252 else
253 253 return problem_in_user_contests? problem
254 254 end
255 255 end
256 256
257 257 protected
258 258 def encrypt_new_password
259 259 return if password.blank?
260 260 self.salt = (10+rand(90)).to_s
261 261 self.hashed_password = User.encrypt(self.password,self.salt)
262 262 end
263 263
264 264 def assign_default_site
265 265 # have to catch error when migrating (because self.site is not available).
266 266 begin
267 267 if self.site==nil
268 268 self.site = Site.find_by_name('default')
269 269 if self.site==nil
270 270 self.site = Site.find(1) # when 'default has be renamed'
271 271 end
272 272 end
273 273 rescue
274 274 end
275 275 end
276 276
277 277 def assign_default_contest
278 278 # have to catch error when migrating (because self.site is not available).
279 279 begin
280 280 if self.contests.length == 0
281 281 default_contest = Contest.find_by_name(GraderConfiguration['contest.default_contest_name'])
282 282 if default_contest
283 283 self.contests = [default_contest]
284 284 end
285 285 end
286 286 rescue
287 287 end
288 288 end
289 289
290 290 def password_required?
291 291 self.hashed_password.blank? || !self.password.blank?
292 292 end
293 293
294 294 def self.encrypt(string,salt)
295 295 Digest::SHA1.hexdigest(salt + string)
296 296 end
297 297
298 298 def uniqueness_of_email_from_activated_users
299 299 user = User.activated_users.find_by_email(self.email)
300 300 if user and (user.login != self.login)
301 - self.errors.add_to_base("Email has already been taken")
301 + self.errors.add(:base,"Email has already been taken")
302 302 end
303 303 end
304 304
305 305 def enough_time_interval_between_same_email_registrations
306 306 return if !self.new_record?
307 307 return if self.activated
308 308 open_user = User.find_by_email(self.email,
309 309 :order => 'created_at DESC')
310 310 if open_user and open_user.created_at and
311 311 (open_user.created_at > Time.now.gmtime - 5.minutes)
312 - self.errors.add_to_base("There are already unactivated registrations with this e-mail address (please wait for 5 minutes)")
312 + self.errors.add(:base,"There are already unactivated registrations with this e-mail address (please wait for 5 minutes)")
313 313 end
314 314 end
315 315
316 316 def email_validation?
317 317 begin
318 318 return VALIDATE_USER_EMAILS
319 319 rescue
320 320 return false
321 321 end
322 322 end
323 323 end
You need to be logged in to leave comments. Login now