cafe-grader-web

Commit r846:4279bf26f98b public

parent | child
Description:
fix wrong merge
Commit status:
[Not Reviewed]
References:
algo
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

r846:4279bf26f98b - - 1 file changed: 78 inserted, 5 deleted

Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -88,341 +88,414
88 88 end
89 89 end
90 90
91 91 def login_with_name
92 92 "[#{login}] #{full_name}"
93 93 end
94 94
95 95 def authenticated_by_cucas?(password)
96 96 url = URI.parse('https://www.cas.chula.ac.th/cas/api/?q=studentAuthenticate')
97 97 appid = '41508763e340d5858c00f8c1a0f5a2bb'
98 98 appsecret ='d9cbb5863091dbe186fded85722a1e31'
99 99 post_args = {
100 100 'appid' => appid,
101 101 'appsecret' => appsecret,
102 102 'username' => login,
103 103 'password' => password
104 104 }
105 105
106 106 #simple call
107 107 begin
108 108 http = Net::HTTP.new('www.cas.chula.ac.th', 443)
109 109 http.use_ssl = true
110 110 http.verify_mode = OpenSSL::SSL::VERIFY_NONE
111 111 result = [ ]
112 112 http.start do |http|
113 113 req = Net::HTTP::Post.new('/cas/api/?q=studentAuthenticate')
114 114 #req = Net::HTTP::Post.new('/appX/prod/?q=studentAuthenticate')
115 115 #req = Net::HTTP::Post.new('/app2/prod/api/?q=studentAuthenticate')
116 116 param = "appid=#{appid}&appsecret=#{appsecret}&username=#{login}&password=#{password}"
117 117 resp = http.request(req,param)
118 118 result = JSON.parse resp.body
119 119 puts result
120 120 end
121 121 return true if result["type"] == "beanStudent"
122 122 rescue => e
123 123 puts e
124 124 puts e.message
125 125 return false
126 126 end
127 127 return false
128 128 end
129 129
130 130 def admin?
131 131 has_role?('admin')
132 132 end
133 133
134 134 def has_role?(role)
135 135 self.roles.where(name: role).count > 0
136 136 end
137 137
138 138 def email_for_editing
139 139 if self.email==nil
140 140 "(unknown)"
141 141 elsif self.email==''
142 142 "(blank)"
143 143 else
144 144 self.email
145 145 end
146 146 end
147 147
148 148 def email_for_editing=(e)
149 149 self.email=e
150 150 end
151 151
152 152 def alias_for_editing
153 153 if self.alias==nil
154 154 "(unknown)"
155 155 elsif self.alias==''
156 156 "(blank)"
157 157 else
158 158 self.alias
159 159 end
160 160 end
161 161
162 162 def alias_for_editing=(e)
163 163 self.alias=e
164 164 end
165 165
166 166 def activation_key
167 167 if self.hashed_password==nil
168 168 encrypt_new_password
169 169 end
170 170 Digest::SHA1.hexdigest(self.hashed_password)[0..7]
171 171 end
172 172
173 173 def verify_activation_key(key)
174 174 key == activation_key
175 175 end
176 176
177 177 def self.random_password(length=5)
178 178 chars = 'abcdefghjkmnopqrstuvwxyz'
179 179 password = ''
180 180 length.times { password << chars[rand(chars.length - 1)] }
181 181 password
182 182 end
183 183
184 - def self.find_non_admin_with_prefix(prefix='')
185 - users = User.all
186 - return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
187 - end
188 -
189 184 # Contest information
190 185
191 186 def self.find_users_with_no_contest()
192 187 users = User.all
193 188 return users.find_all { |u| u.contests.length == 0 }
194 189 end
195 190
196 191
197 192 def contest_time_left
198 193 if GraderConfiguration.contest_mode?
199 194 return nil if site==nil
200 195 return site.time_left
201 196 elsif GraderConfiguration.indv_contest_mode?
202 197 time_limit = GraderConfiguration.contest_time_limit
203 198 if time_limit == nil
204 199 return nil
205 200 end
206 201 if contest_stat==nil or contest_stat.started_at==nil
207 202 return (Time.now.gmtime + time_limit) - Time.now.gmtime
208 203 else
209 204 finish_time = contest_stat.started_at + time_limit
210 205 current_time = Time.now.gmtime
211 206 if current_time > finish_time
212 207 return 0
213 208 else
214 209 return finish_time - current_time
215 210 end
216 211 end
217 212 else
218 213 return nil
219 214 end
220 215 end
221 216
222 217 def contest_finished?
223 218 if GraderConfiguration.contest_mode?
224 219 return false if site==nil
225 220 return site.finished?
226 221 elsif GraderConfiguration.indv_contest_mode?
227 222 return false if self.contest_stat==nil
228 223 return contest_time_left == 0
229 224 else
230 225 return false
231 226 end
232 227 end
233 228
234 229 def contest_started?
235 230 if GraderConfiguration.indv_contest_mode?
236 231 stat = self.contest_stat
237 232 return ((stat != nil) and (stat.started_at != nil))
238 233 elsif GraderConfiguration.contest_mode?
239 234 return true if site==nil
240 235 return site.started
241 236 else
242 237 return true
243 238 end
244 239 end
245 240
246 241 def update_start_time
247 242 stat = self.contest_stat
248 243 if stat.nil? or stat.started_at.nil?
249 244 stat ||= UserContestStat.new(:user => self)
250 245 stat.started_at = Time.now.gmtime
251 246 stat.save
252 247 end
253 248 end
254 249
255 250 def problem_in_user_contests?(problem)
256 251 problem_contests = problem.contests.all
257 252
258 253 if problem_contests.length == 0 # this is public contest
259 254 return true
260 255 end
261 256
262 257 contests.each do |contest|
263 258 if problem_contests.find {|c| c.id == contest.id }
264 259 return true
265 260 end
266 261 end
267 262 return false
268 263 end
269 264
270 265 def available_problems_group_by_contests
271 266 contest_problems = []
272 267 pin = {}
273 268 contests.enabled.each do |contest|
274 269 available_problems = contest.problems.available
275 270 contest_problems << {
276 271 :contest => contest,
277 272 :problems => available_problems
278 273 }
279 274 available_problems.each {|p| pin[p.id] = true}
280 275 end
281 276 other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
282 277 contest_problems << {
283 278 :contest => nil,
284 279 :problems => other_avaiable_problems
285 280 }
286 281 return contest_problems
287 282 end
288 283
289 284 def solve_all_available_problems?
290 285 available_problems.each do |p|
291 286 u = self
292 287 sub = Submission.find_last_by_user_and_problem(u.id,p.id)
293 288 return false if !p or !sub or sub.points < p.full_score
294 289 end
295 290 return true
296 291 end
297 292
298 293 #get a list of available problem
299 294 def available_problems
300 295 # first, we check if this is normal mode
301 296 if not GraderConfiguration.multicontests?
302 297
303 298 #if this is a normal mode
304 299 #we show problem based on problem_group, if the config said so
305 300 if GraderConfiguration.use_problem_group?
306 301 return available_problems_in_group
307 302 else
308 303 return Problem.available_problems
309 304 end
310 305 else
311 306 #this is multi contest mode
312 307 contest_problems = []
313 308 pin = {}
314 309 contests.enabled.each do |contest|
315 310 contest.problems.available.each do |problem|
316 311 if not pin.has_key? problem.id
317 312 contest_problems << problem
318 313 end
319 314 pin[problem.id] = true
320 315 end
321 316 end
322 317 other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
323 318 return contest_problems + other_avaiable_problems
324 319 end
325 320 end
326 321
327 322 # new feature, get list of available problem in all enabled group that the user belongs to
328 323 def available_problems_in_group
329 324 problem = []
330 325 self.groups.where(enabled: true).each do |group|
331 326 group.problems.where(available: true).each { |p| problem << p }
332 327 end
333 328 problem.uniq!
334 329 if problem
335 330 problem.sort! do |a,b|
336 331 case
337 332 when a.date_added < b.date_added
338 333 1
339 334 when a.date_added > b.date_added
340 335 -1
341 336 else
342 337 a.name <=> b.name
343 338 end
344 339 end
345 340 return problem
346 341 else
347 342 return []
348 343 end
349 344 end
350 345
351 346 #check if the user has the right to view that problem
352 347 #this also consider group based problem policy
353 348 def can_view_problem?(problem)
354 349 return true if admin?
355 350 return available_problems.include? problem
356 351 end
357 352
358 353 def self.clear_last_login
359 354 User.update_all(:last_ip => nil)
360 355 end
361 356
357 + #create multiple user, one per lines of input
358 + def self.create_from_list(lines)
359 + error_logins = []
360 + first_error = nil
361 + created_users = []
362 +
363 + lines.split("\n").each do |line|
364 + #split with large limit, this will cause consecutive ',' to be result in a blank
365 + items = line.chomp.split(',',1000)
366 + if items.length>=2
367 + login = items[0]
368 + full_name = items[1]
369 + remark =''
370 + user_alias = ''
371 +
372 + added_random_password = false
373 + added_password = false
374 +
375 + #given password?
376 + if items.length >= 3
377 + if items[2].chomp(" ").length > 0
378 + password = items[2].chomp(" ")
379 + added_password = true
380 + end
381 + else
382 + password = random_password
383 + added_random_password=true;
384 + end
385 +
386 + #given alias?
387 + if items.length>= 4 and items[3].chomp(" ").length > 0;
388 + user_alias = items[3].chomp(" ")
389 + else
390 + user_alias = login
391 + end
392 +
393 + #given remark?
394 + has_remark = false
395 + if items.length>=5
396 + remark = items[4].strip;
397 + has_remark = true
398 + end
399 +
400 + user = User.find_by_login(login)
401 + if (user)
402 + user.full_name = full_name
403 + user.remark = remark if has_remark
404 + user.password = password if added_password || added_random_password
405 + else
406 + #create a random password if none are given
407 + password = random_password unless password
408 + user = User.new({:login => login,
409 + :full_name => full_name,
410 + :password => password,
411 + :password_confirmation => password,
412 + :alias => user_alias,
413 + :remark => remark})
414 + end
415 + user.activated = true
416 +
417 + if user.save
418 + created_users << user
419 + else
420 + error_logins << "'#{login}'"
421 + first_error = user.errors.full_messages.to_sentence unless first_error
422 + end
423 + end
424 + end
425 +
426 + return {error_logins: error_logins, first_error: first_error, created_users: created_users}
427 +
428 + end
429 +
430 + def self.find_non_admin_with_prefix(prefix='')
431 + users = User.all
432 + return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
433 + end
434 +
362 435 protected
363 436 def encrypt_new_password
364 437 return if password.blank?
365 438 self.salt = (10+rand(90)).to_s
366 439 self.hashed_password = User.encrypt(self.password,self.salt)
367 440 end
368 441
369 442 def assign_default_site
370 443 # have to catch error when migrating (because self.site is not available).
371 444 begin
372 445 if self.site==nil
373 446 self.site = Site.find_by_name('default')
374 447 if self.site==nil
375 448 self.site = Site.find(1) # when 'default has be renamed'
376 449 end
377 450 end
378 451 rescue
379 452 end
380 453 end
381 454
382 455 def assign_default_contest
383 456 # have to catch error when migrating (because self.site is not available).
384 457 begin
385 458 if self.contests.length == 0
386 459 default_contest = Contest.find_by_name(GraderConfiguration['contest.default_contest_name'])
387 460 if default_contest
388 461 self.contests = [default_contest]
389 462 end
390 463 end
391 464 rescue
392 465 end
393 466 end
394 467
395 468 def password_required?
396 469 self.hashed_password.blank? || !self.password.blank?
397 470 end
398 471
399 472 def self.encrypt(string,salt)
400 473 Digest::SHA1.hexdigest(salt + string)
401 474 end
402 475
403 476 def uniqueness_of_email_from_activated_users
404 477 user = User.activated_users.find_by_email(self.email)
405 478 if user and (user.login != self.login)
406 479 self.errors.add(:base,"Email has already been taken")
407 480 end
408 481 end
409 482
410 483 def enough_time_interval_between_same_email_registrations
411 484 return if !self.new_record?
412 485 return if self.activated
413 486 open_user = User.find_by_email(self.email,
414 487 :order => 'created_at DESC')
415 488 if open_user and open_user.created_at and
416 489 (open_user.created_at > Time.now.gmtime - 5.minutes)
417 490 self.errors.add(:base,"There are already unactivated registrations with this e-mail address (please wait for 5 minutes)")
418 491 end
419 492 end
420 493
421 494 def email_validation?
422 495 begin
423 496 return VALIDATE_USER_EMAILS
424 497 rescue
425 498 return false
426 499 end
427 500 end
428 501 end
You need to be logged in to leave comments. Login now