cafe-grader-web

Commit r302:77a5c6e76df3 public

parent | child
Description:
shows contest start confirmation for indv contest
Commit status:
[Not Reviewed]
References:
default
Diff options:
Raw Diff | Patch Diff | Download Diff | Show 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

r302:77a5c6e76df3 - - 4 files changed: 45 inserted, 4 deleted

Show file before | Show file after | Raw diff | Download diff | Show whitespace Increase context Show commentsHide comments
@@ -0,0 +1,12
1 + = user_title_bar(@user)
2 +
3 + %center
4 + You will participate in contest:
5 + - @contests.each do |contest|
6 + = contest.title
7 + %br
8 +
9 + The timer will start after you click the start button.
10 +
11 + - form_tag :action => 'confirm_contest_start', :method => 'post' do
12 + = submit_tag 'Start!', :confirm => 'Are you sure?'
Show file before | Show file after | Raw diff | Download diff | Show whitespace Increase context Show commentsHide comments
@@ -1,356 +1,376
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 - append_before_filter :update_user_start_time, :except => [:index, :login]
6 + append_before_filter :confirm_and_update_start_time,
7 + :except => [:index,
8 + :login,
9 + :confirm_contest_start]
7 10
8 11 # to prevent log in box to be shown when user logged out of the
9 12 # system only in some tab
10 - prepend_before_filter :reject_announcement_refresh_when_logged_out, :only => [:announcements]
13 + prepend_before_filter :reject_announcement_refresh_when_logged_out,
14 + :only => [:announcements]
11 15
12 16 # COMMENTED OUT: filter in each action instead
13 17 # before_filter :verify_time_limit, :only => [:submit]
14 18
15 19 verify :method => :post, :only => [:submit],
16 20 :redirect_to => { :action => :index }
17 21
18 22 # COMMENT OUT: only need when having high load
19 23 # caches_action :index, :login
20 24
21 25 # NOTE: This method is not actually needed, 'config/routes.rb' has
22 26 # assigned action login as a default action.
23 27 def index
24 28 redirect_to :action => 'login'
25 29 end
26 30
27 31 def login
28 32 saved_notice = flash[:notice]
29 33 reset_session
30 34 flash.now[:notice] = saved_notice
31 35
32 36 # EXPERIMENT:
33 37 # Hide login if in single user mode and the url does not
34 38 # explicitly specify /login
35 39 #
36 40 # logger.info "PATH: #{request.path}"
37 41 # if Configuration['system.single_user_mode'] and
38 42 # request.path!='/main/login'
39 43 # @hidelogin = true
40 44 # end
41 45
42 46 @announcements = Announcement.find_for_frontpage
43 47 render :action => 'login', :layout => 'empty'
44 48 end
45 49
46 50 def list
47 51 prepare_list_information
48 52 end
49 53
50 54 def help
51 55 @user = User.find(session[:user_id])
52 56 end
53 57
54 58 def submit
55 59 user = User.find(session[:user_id])
56 60
57 61 @submission = Submission.new(params[:submission])
58 62 @submission.user = user
59 63 @submission.language_id = 0
60 64 if (params['file']) and (params['file']!='')
61 65 @submission.source = params['file'].read
62 66 @submission.source_filename = params['file'].original_filename
63 67 end
64 68 @submission.submitted_at = Time.new.gmtime
65 69
66 70 if Configuration.time_limit_mode? and user.contest_finished?
67 71 @submission.errors.add_to_base "The contest is over."
68 72 prepare_list_information
69 73 render :action => 'list' and return
70 74 end
71 75
72 76 if @submission.valid?
73 77 if @submission.save == false
74 78 flash[:notice] = 'Error saving your submission'
75 79 elsif Task.create(:submission_id => @submission.id,
76 80 :status => Task::STATUS_INQUEUE) == false
77 81 flash[:notice] = 'Error adding your submission to task queue'
78 82 end
79 83 else
80 84 prepare_list_information
81 85 render :action => 'list' and return
82 86 end
83 87 redirect_to :action => 'list'
84 88 end
85 89
86 90 def source
87 91 submission = Submission.find(params[:id])
88 92 if submission.user_id == session[:user_id]
89 93 send_data(submission.source,
90 94 {:filename => submission.download_filename,
91 95 :type => 'text/plain'})
92 96 else
93 97 flash[:notice] = 'Error viewing source'
94 98 redirect_to :action => 'list'
95 99 end
96 100 end
97 101
98 102 def compiler_msg
99 103 @submission = Submission.find(params[:id])
100 104 if @submission.user_id == session[:user_id]
101 105 render :action => 'compiler_msg', :layout => 'empty'
102 106 else
103 107 flash[:notice] = 'Error viewing source'
104 108 redirect_to :action => 'list'
105 109 end
106 110 end
107 111
108 112 def submission
109 113 @user = User.find(session[:user_id])
110 114 @problems = @user.available_problems
111 115 if params[:id]==nil
112 116 @problem = nil
113 117 @submissions = nil
114 118 else
115 119 @problem = Problem.find_by_name(params[:id])
116 120 if not @problem.available
117 121 redirect_to :action => 'list'
118 122 flash[:notice] = 'Error: submissions for that problem are not viewable.'
119 123 return
120 124 end
121 125 @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id)
122 126 end
123 127 end
124 128
125 129 def result
126 130 if !Configuration.show_grading_result
127 131 redirect_to :action => 'list' and return
128 132 end
129 133 @user = User.find(session[:user_id])
130 134 @submission = Submission.find(params[:id])
131 135 if @submission.user!=@user
132 136 flash[:notice] = 'You are not allowed to view result of other users.'
133 137 redirect_to :action => 'list' and return
134 138 end
135 139 prepare_grading_result(@submission)
136 140 end
137 141
138 142 def load_output
139 143 if !Configuration.show_grading_result or params[:num]==nil
140 144 redirect_to :action => 'list' and return
141 145 end
142 146 @user = User.find(session[:user_id])
143 147 @submission = Submission.find(params[:id])
144 148 if @submission.user!=@user
145 149 flash[:notice] = 'You are not allowed to view result of other users.'
146 150 redirect_to :action => 'list' and return
147 151 end
148 152 case_num = params[:num].to_i
149 153 out_filename = output_filename(@user.login,
150 154 @submission.problem.name,
151 155 @submission.id,
152 156 case_num)
153 157 if !FileTest.exists?(out_filename)
154 158 flash[:notice] = 'Output not found.'
155 159 redirect_to :action => 'list' and return
156 160 end
157 161
158 162 if defined?(USE_APACHE_XSENDFILE) and USE_APACHE_XSENDFILE
159 163 response.headers['Content-Type'] = "application/force-download"
160 164 response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
161 165 response.headers["X-Sendfile"] = out_filename
162 166 response.headers['Content-length'] = File.size(out_filename)
163 167 render :nothing => true
164 168 else
165 169 send_file out_filename, :stream => false, :filename => "output-#{case_num}.txt", :type => "text/plain"
166 170 end
167 171 end
168 172
169 173 def error
170 174 @user = User.find(session[:user_id])
171 175 end
172 176
173 177 # announcement refreshing and hiding methods
174 178
175 179 def announcements
176 180 if params.has_key? 'recent'
177 181 prepare_announcements(params[:recent])
178 182 else
179 183 prepare_announcements
180 184 end
181 185 render(:partial => 'announcement',
182 186 :collection => @announcements,
183 187 :locals => {:announcement_effect => true})
184 188 end
185 189
190 + def confirm_contest_start
191 + user = User.find(session[:user_id])
192 + if request.method == :post
193 + user.update_start_time
194 + redirect_to :action => 'list'
195 + else
196 + @contests = user.contests
197 + @user = user
198 + end
199 + end
200 +
186 201 protected
187 202
188 203 def prepare_announcements(recent=nil)
189 204 if Configuration.show_tasks_to?(@user)
190 205 @announcements = Announcement.find_published(true)
191 206 else
192 207 @announcements = Announcement.find_published
193 208 end
194 209 if recent!=nil
195 210 recent_id = recent.to_i
196 211 @announcements = @announcements.find_all { |a| a.id > recent_id }
197 212 end
198 213 end
199 214
200 215 def prepare_list_information
201 216 @user = User.find(session[:user_id])
202 217 if not Configuration.multicontests?
203 218 @problems = @user.available_problems
204 219 else
205 220 @contest_problems = @user.available_problems_group_by_contests
206 221 @problems = @user.available_problems
207 222 end
208 223 @prob_submissions = {}
209 224 @problems.each do |p|
210 225 sub = Submission.find_last_by_user_and_problem(@user.id,p.id)
211 226 if sub!=nil
212 227 @prob_submissions[p.id] = { :count => sub.number, :submission => sub }
213 228 else
214 229 @prob_submissions[p.id] = { :count => 0, :submission => nil }
215 230 end
216 231 end
217 232 prepare_announcements
218 233 end
219 234
220 235 def check_viewability
221 236 @user = User.find(session[:user_id])
222 237 if (!Configuration.show_tasks_to?(@user)) and
223 238 ((action_name=='submission') or (action_name=='submit'))
224 239 redirect_to :action => 'list' and return
225 240 end
226 241 end
227 242
228 243 def prepare_grading_result(submission)
229 244 if Configuration.task_grading_info.has_key? submission.problem.name
230 245 grading_info = Configuration.task_grading_info[submission.problem.name]
231 246 else
232 247 # guess task info from problem.full_score
233 248 cases = submission.problem.full_score / 10
234 249 grading_info = {
235 250 'testruns' => cases,
236 251 'testcases' => cases
237 252 }
238 253 end
239 254 @test_runs = []
240 255 if grading_info['testruns'].is_a? Integer
241 256 trun_count = grading_info['testruns']
242 257 trun_count.times do |i|
243 258 @test_runs << [ read_grading_result(@user.login,
244 259 submission.problem.name,
245 260 submission.id,
246 261 i+1) ]
247 262 end
248 263 else
249 264 grading_info['testruns'].keys.sort.each do |num|
250 265 run = []
251 266 testrun = grading_info['testruns'][num]
252 267 testrun.each do |c|
253 268 run << read_grading_result(@user.login,
254 269 submission.problem.name,
255 270 submission.id,
256 271 c)
257 272 end
258 273 @test_runs << run
259 274 end
260 275 end
261 276 end
262 277
263 278 def grading_result_dir(user_name, problem_name, submission_id, case_num)
264 279 return "#{GRADING_RESULT_DIR}/#{user_name}/#{problem_name}/#{submission_id}/test-result/#{case_num}"
265 280 end
266 281
267 282 def output_filename(user_name, problem_name, submission_id, case_num)
268 283 dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
269 284 return "#{dir}/output.txt"
270 285 end
271 286
272 287 def read_grading_result(user_name, problem_name, submission_id, case_num)
273 288 dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
274 289 result_file_name = "#{dir}/result"
275 290 if !FileTest.exists?(result_file_name)
276 291 return {:num => case_num, :msg => 'program did not run'}
277 292 else
278 293 results = File.open(result_file_name).readlines
279 294 run_stat = extract_running_stat(results)
280 295 output_filename = "#{dir}/output.txt"
281 296 if FileTest.exists?(output_filename)
282 297 output_file = true
283 298 output_size = File.size(output_filename)
284 299 else
285 300 output_file = false
286 301 output_size = 0
287 302 end
288 303
289 304 return {
290 305 :num => case_num,
291 306 :msg => results[0],
292 307 :run_stat => run_stat,
293 308 :output => output_file,
294 309 :output_size => output_size
295 310 }
296 311 end
297 312 end
298 313
299 314 # copied from grader/script/lib/test_request_helper.rb
300 315 def extract_running_stat(results)
301 316 running_stat_line = results[-1]
302 317
303 318 # extract exit status line
304 319 run_stat = ""
305 320 if !(/[Cc]orrect/.match(results[0]))
306 321 run_stat = results[0].chomp
307 322 else
308 323 run_stat = 'Program exited normally'
309 324 end
310 325
311 326 logger.info "Stat line: #{running_stat_line}"
312 327
313 328 # extract running time
314 329 if res = /r(.*)u(.*)s/.match(running_stat_line)
315 330 seconds = (res[1].to_f + res[2].to_f)
316 331 time_stat = "Time used: #{seconds} sec."
317 332 else
318 333 seconds = nil
319 334 time_stat = "Time used: n/a sec."
320 335 end
321 336
322 337 # extract memory usage
323 338 if res = /s(.*)m/.match(running_stat_line)
324 339 memory_used = res[1].to_i
325 340 else
326 341 memory_used = -1
327 342 end
328 343
329 344 return {
330 345 :msg => "#{run_stat}\n#{time_stat}",
331 346 :running_time => seconds,
332 347 :exit_status => run_stat,
333 348 :memory_usage => memory_used
334 349 }
335 350 end
336 351
337 - def update_user_start_time
352 + def confirm_and_update_start_time
338 353 user = User.find(session[:user_id])
354 + if (Configuration.indv_contest_mode? and
355 + Configuration['contest.confirm_indv_contest_start'] and
356 + !user.contest_started?)
357 + redirect_to :action => 'confirm_contest_start' and return
358 + end
339 359 user.update_start_time
340 360 end
341 361
342 362 def reject_announcement_refresh_when_logged_out
343 363 if not session[:user_id]
344 364 render :text => 'Access forbidden', :status => 403
345 365 end
346 366
347 367 if Configuration.multicontests?
348 368 user = User.find(session[:user_id])
349 369 if user.contest_stat.forced_logout
350 370 render :text => 'Access forbidden', :status => 403
351 371 end
352 372 end
353 373 end
354 374
355 375 end
356 376
Show file before | Show file after | Raw diff | Download diff | Show whitespace Increase context Show commentsHide comments
@@ -79,193 +79,196
79 79 if self.email==nil
80 80 "(unknown)"
81 81 elsif self.email==''
82 82 "(blank)"
83 83 else
84 84 self.email
85 85 end
86 86 end
87 87
88 88 def email_for_editing=(e)
89 89 self.email=e
90 90 end
91 91
92 92 def alias_for_editing
93 93 if self.alias==nil
94 94 "(unknown)"
95 95 elsif self.alias==''
96 96 "(blank)"
97 97 else
98 98 self.alias
99 99 end
100 100 end
101 101
102 102 def alias_for_editing=(e)
103 103 self.alias=e
104 104 end
105 105
106 106 def activation_key
107 107 if self.hashed_password==nil
108 108 encrypt_new_password
109 109 end
110 110 Digest::SHA1.hexdigest(self.hashed_password)[0..7]
111 111 end
112 112
113 113 def verify_activation_key(key)
114 114 key == activation_key
115 115 end
116 116
117 117 def self.random_password(length=5)
118 118 chars = 'abcdefghjkmnopqrstuvwxyz'
119 119 password = ''
120 120 length.times { password << chars[rand(chars.length - 1)] }
121 121 password
122 122 end
123 123
124 124 def self.find_non_admin_with_prefix(prefix='')
125 125 users = User.find(:all)
126 126 return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
127 127 end
128 128
129 129 # Contest information
130 130
131 131 def self.find_users_with_no_contest()
132 132 users = User.find(:all)
133 133 return users.find_all { |u| u.contests.length == 0 }
134 134 end
135 135
136 136
137 137 def contest_time_left
138 138 if Configuration.contest_mode?
139 139 return nil if site==nil
140 140 return site.time_left
141 141 elsif Configuration.indv_contest_mode?
142 142 time_limit = Configuration.contest_time_limit
143 143 if time_limit == nil
144 144 return nil
145 145 end
146 146 if contest_stat==nil or contest_stat.started_at==nil
147 147 return (Time.now.gmtime + time_limit) - Time.now.gmtime
148 148 else
149 149 finish_time = contest_stat.started_at + time_limit
150 150 current_time = Time.now.gmtime
151 151 if current_time > finish_time
152 152 return 0
153 153 else
154 154 return finish_time - current_time
155 155 end
156 156 end
157 157 else
158 158 return nil
159 159 end
160 160 end
161 161
162 162 def contest_finished?
163 163 if Configuration.contest_mode?
164 164 return false if site==nil
165 165 return site.finished?
166 166 elsif Configuration.indv_contest_mode?
167 167 return false if self.contest_stat(true)==nil
168 168 return contest_time_left == 0
169 169 else
170 170 return false
171 171 end
172 172 end
173 173
174 174 def contest_started?
175 - if Configuration.contest_mode?
175 + if Configuration.indv_contest_mode?
176 + stat = self.contest_stat
177 + return ((stat != nil) and (stat.started_at != nil))
178 + elsif Configuration.contest_mode?
176 179 return true if site==nil
177 180 return site.started
178 181 else
179 182 return true
180 183 end
181 184 end
182 185
183 186 def update_start_time
184 187 stat = self.contest_stat
185 188 if stat == nil or stat.started_at == nil
186 189 stat ||= UserContestStat.new(:user => self)
187 190 stat.started_at = Time.now.gmtime
188 191 stat.save
189 192 end
190 193 end
191 194
192 195 def problem_in_user_contests?(problem)
193 196 problem_contests = problem.contests.all
194 197
195 198 if problem_contests.length == 0 # this is public contest
196 199 return true
197 200 end
198 201
199 202 contests.each do |contest|
200 203 if problem_contests.find {|c| c.id == contest.id }
201 204 return true
202 205 end
203 206 end
204 207 return false
205 208 end
206 209
207 210 def available_problems_group_by_contests
208 211 contest_problems = []
209 212 pin = {}
210 213 contests.enabled.each do |contest|
211 214 available_problems = contest.problems.available
212 215 contest_problems << {
213 216 :contest => contest,
214 217 :problems => available_problems
215 218 }
216 219 available_problems.each {|p| pin[p.id] = true}
217 220 end
218 221 other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
219 222 contest_problems << {
220 223 :contest => nil,
221 224 :problems => other_avaiable_problems
222 225 }
223 226 return contest_problems
224 227 end
225 228
226 229 def available_problems
227 230 if not Configuration.multicontests?
228 231 return Problem.find_available_problems
229 232 else
230 233 contest_problems = []
231 234 pin = {}
232 235 contests.enabled.each do |contest|
233 236 contest.problems.available.each do |problem|
234 237 if not pin.has_key? problem.id
235 238 contest_problems << problem
236 239 end
237 240 pin[problem.id] = true
238 241 end
239 242 end
240 243 other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
241 244 return contest_problems + other_avaiable_problems
242 245 end
243 246 end
244 247
245 248 def can_view_problem?(problem)
246 249 if not Configuration.multicontests?
247 250 return problem.available
248 251 else
249 252 return problem_in_user_contests? problem
250 253 end
251 254 end
252 255
253 256 protected
254 257 def encrypt_new_password
255 258 return if password.blank?
256 259 self.salt = (10+rand(90)).to_s
257 260 self.hashed_password = User.encrypt(self.password,self.salt)
258 261 end
259 262
260 263 def assign_default_site
261 264 # have to catch error when migrating (because self.site is not available).
262 265 begin
263 266 if self.site==nil
264 267 self.site = Site.find_by_name('default')
265 268 if self.site==nil
266 269 self.site = Site.find(1) # when 'default has be renamed'
267 270 end
268 271 end
269 272 rescue
270 273 end
271 274 end
Show file before | Show file after | Raw diff | Download diff | Show whitespace Increase context Show commentsHide comments
@@ -8,177 +8,183
8 8 },
9 9
10 10 {
11 11 :key => 'ui.front.title',
12 12 :value_type => 'string',
13 13 :default_value => 'Grader'
14 14 },
15 15
16 16 {
17 17 :key => 'ui.front.welcome_message',
18 18 :value_type => 'string',
19 19 :default_value => 'Welcome!'
20 20 },
21 21
22 22 {
23 23 :key => 'ui.show_score',
24 24 :value_type => 'boolean',
25 25 :default_value => 'true'
26 26 },
27 27
28 28 {
29 29 :key => 'contest.time_limit',
30 30 :value_type => 'string',
31 31 :default_value => 'unlimited',
32 32 :description => 'Time limit in format hh:mm, or "unlimited" for contests with no time limits. This config is CACHED. Restart the server before the change can take effect.'
33 33 },
34 34
35 35 {
36 36 :key => 'system.mode',
37 37 :value_type => 'string',
38 38 :default_value => 'standard',
39 39 :description => 'Current modes are "standard", "contest", "indv-contest", and "analysis".'
40 40 },
41 41
42 42 {
43 43 :key => 'contest.name',
44 44 :value_type => 'string',
45 45 :default_value => 'Grader',
46 46 :description => 'This name will be shown on the user header bar.'
47 47 },
48 48
49 49 {
50 50 :key => 'contest.multisites',
51 51 :value_type => 'boolean',
52 52 :default_value => 'false',
53 53 :description => 'If the server is in contest mode and this option is true, on the log in of the admin a menu for site selections is shown.'
54 54 },
55 55
56 56 {
57 57 :key => 'system.online_registration',
58 58 :value_type => 'boolean',
59 59 :default_value => 'false',
60 60 :description => 'This option enables online registration.'
61 61 },
62 62
63 63 # If Configuration['system.online_registration'] is true, the
64 64 # system allows online registration, and will use these
65 65 # information for sending confirmation emails.
66 66 {
67 67 :key => 'system.online_registration.smtp',
68 68 :value_type => 'string',
69 69 :default_value => 'smtp.somehost.com'
70 70 },
71 71
72 72 {
73 73 :key => 'system.online_registration.from',
74 74 :value_type => 'string',
75 75 :default_value => 'your.email@address'
76 76 },
77 77
78 78 {
79 79 :key => 'system.admin_email',
80 80 :value_type => 'string',
81 81 :default_value => 'admin@admin.email'
82 82 },
83 83
84 84 {
85 85 :key => 'system.user_setting_enabled',
86 86 :value_type => 'boolean',
87 87 :default_value => 'true',
88 88 :description => 'If this option is true, users can change their settings'
89 89 },
90 90
91 91 # If Configuration['contest.test_request.early_timeout'] is true
92 92 # the user will not be able to use test request at 30 minutes
93 93 # before the contest ends.
94 94 {
95 95 :key => 'contest.test_request.early_timeout',
96 96 :value_type => 'boolean',
97 97 :default_value => 'false'
98 98 },
99 99
100 100 {
101 101 :key => 'system.multicontests',
102 102 :value_type => 'boolean',
103 103 :default_value => 'false'
104 + },
105 +
106 + {
107 + :key => 'contest.confirm_indv_contest_start',
108 + :value_type => 'boolean',
109 + :default_value => 'false'
104 110 }
105 111 ]
106 112
107 113
108 114 def create_configuration_key(key,
109 115 value_type,
110 116 default_value,
111 117 description='')
112 118 conf = (Configuration.find_by_key(key) ||
113 119 Configuration.new(:key => key,
114 120 :value_type => value_type,
115 121 :value => default_value))
116 122 conf.description = description
117 123 conf.save
118 124 end
119 125
120 126 def seed_config
121 127 CONFIGURATIONS.each do |conf|
122 128 if conf.has_key? :description
123 129 desc = conf[:description]
124 130 else
125 131 desc = ''
126 132 end
127 133 create_configuration_key(conf[:key],
128 134 conf[:value_type],
129 135 conf[:default_value],
130 136 desc)
131 137 end
132 138 end
133 139
134 140 def seed_roles
135 141 return if Role.find_by_name('admin')
136 142
137 143 role = Role.create(:name => 'admin')
138 144 user_admin_right = Right.create(:name => 'user_admin',
139 145 :controller => 'user_admin',
140 146 :action => 'all')
141 147 problem_admin_right = Right.create(:name=> 'problem_admin',
142 148 :controller => 'problems',
143 149 :action => 'all')
144 150
145 151 graders_right = Right.create(:name => 'graders_admin',
146 152 :controller => 'graders',
147 153 :action => 'all')
148 154
149 155 role.rights << user_admin_right;
150 156 role.rights << problem_admin_right;
151 157 role.rights << graders_right;
152 158 role.save
153 159 end
154 160
155 161 def seed_root
156 162 return if User.find_by_login('root')
157 163
158 164 root = User.new(:login => 'root',
159 165 :full_name => 'Administrator',
160 166 :alias => 'root')
161 167 root.password = 'ioionrails';
162 168
163 169 class << root
164 170 public :encrypt_new_password
165 171 def valid?
166 172 true
167 173 end
168 174 end
169 175
170 176 root.encrypt_new_password
171 177
172 178 root.roles << Role.find_by_name('admin')
173 179
174 180 root.activated = true
175 181 root.save
176 182 end
177 183
178 184 def seed_users_and_roles
179 185 seed_roles
180 186 seed_root
181 187 end
182 188
183 189 seed_config
184 190 seed_users_and_roles
You need to be logged in to leave comments. Login now