cafe-grader-web Commit - r295:4f81b9ab5d77

cafe-grader-web

Commit `r295:4f81b9ab5d77` public

parent | child

Description:

a cleaner, testable way to log out user after contest changed

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r295:4f81b9ab5d77 - Sun, 28 Mar 2010 14:31:57 - 11 files changed: 170 inserted, 18 deleted

db/migrate/20100328123325_add_forced_logout_to_user_contest_stat.rb created 644 ¶ +9

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

spec/controllers/user_admin_controller_spec.rb created 644 ¶ +73

@@ -0,0 +1,73
	1	+ require 'delorean'
	2	+
	3	+ require File.dirname(__FILE__) + '/../spec_helper'
	4	+ require File.dirname(__FILE__) + '/../config_spec_helper'
	5	+
	6	+ describe UserAdminController, "when manage contest" do
	7	+
	8	+ include ConfigSpecHelperMethods
	9	+
	10	+ fixtures :users
	11	+ fixtures :problems
	12	+ fixtures :contests
	13	+ fixtures :roles
	14	+
	15	+ def change_users_contest_to(user_login_list, contest, reset_timer=false)
	16	+ post_data = {
	17	+ :contest => {:id => contest.id},
	18	+ :operation => 'assign',
	19	+ :login_list => user_login_list
	20	+ }
	21	+ post_data[:reset_timer] = true if reset_timer
	22	+ post 'manage_contest', post_data, {:user_id => @admin_user.id}
	23	+ end
	24	+
	25	+ before(:each) do
	26	+ @admin_user = users(:mary)
	27	+ @contest_b = contests(:contest_b)
	28	+ @james = users(:james)
	29	+ @jack = users(:jack)
	30	+
	31	+ set_contest_time_limit('3:00')
	32	+ set_indv_contest_mode
	33	+ end
	34	+
	35	+ it "should allow admin to see contest management page" do
	36	+ get 'contest_management', {}, {:user_id => @admin_user.id}
	37	+
	38	+ response.should render_template 'user_admin/contest_management'
	39	+ end
	40	+
	41	+ it "should change users' contest" do
	42	+ change_users_contest_to("james\njack", @contest_b)
	43	+ response.should redirect_to :action => 'contest_management'
	44	+
	45	+ @james.contests(true).should include @contest_b
	46	+ @jack.contests(true).should_not include @contest_a
	47	+ end
	48	+
	49	+ it "should reset users' timer when their contests change" do
	50	+ @james.update_start_time
	51	+
	52	+ Delorean.time_travel_to(190.minutes.since) do
	53	+ @james.contest_finished?.should be_true
	54	+
	55	+ change_users_contest_to("james", @contest_b, true)
	56	+
	57	+ @james.contest_finished?.should be_false
	58	+ end
	59	+ end
	60	+
	61	+ it "should set forced_logout flag for users when their contests change" do
	62	+ @james.update_start_time
	63	+
	64	+ Delorean.time_travel_to(190.minutes.since) do
	65	+ @james.contest_finished?.should be_true
	66	+
	67	+ change_users_contest_to("james", @contest_b, true)
	68	+
	69	+ @james.contest_stat(true).forced_logout.should be_true
	70	+ end
	71	+ end
	72	+
	73	+ end

app/controllers/application_controller.rb ¶ +12 -2

               # Filters added to this controller apply to all controllers in the application.
               # Likewise, all the methods added will be available for all controllers.
               class ApplicationController < ActionController::Base
                 SINGLE_USER_MODE_CONF_KEY = 'system.single_user_mode'
                 def admin_authorization
                   return false unless authenticate
                   user = User.find(session[:user_id], :include => ['roles'])
                   redirect_to :controller => 'main', :action => 'login' unless user.admin?
                 end
                 def authorization_by_roles(allowed_roles)
                   return false unless authenticate
                   user = User.find(session[:user_id])
                   unless user.roles.detect { |role| allowed_roles.member?(role.name) }
                     flash[:notice] = 'You are not authorized to view the page you requested'
                     redirect_to :controller => 'main', :action => 'login'
                     return false
                   end
                 end
                 protected
                 def authenticate
                   unless session[:user_id]
                     redirect_to :controller => 'main', :action => 'login'
                     return false
                   end
-            -     #Configuration.reload
                   # check if run in single user mode
-            -     if (Configuration[SINGLE_USER_MODE_CONF_KEY])
+            +     if Configuration[SINGLE_USER_MODE_CONF_KEY]
                     user = User.find(session[:user_id])
                     if user==nil or (not user.admin?)
                       redirect_to :controller => 'main', :action => 'login'
                       return false
                     end
+            +       return true
                   end
+            +     if Configuration.multicontests?
+            +       user = User.find(session[:user_id])
+            +       begin
+            +         if user.contest_stat(true).forced_logout
+            +           flash[:notice] = 'You have been automatically logged out.'
+            +           redirect_to :controller => 'main', :action => 'index'
+            +         end
+            +       rescue
+            +       end
+            +     end
                   return true
                 end
                 def authorization
                   return false unless authenticate
                   user = User.find(session[:user_id])
                   unless user.roles.detect { |role|
               	role.rights.detect{ |right|
               	  right.controller == self.class.controller_name and
                         (right.action == 'all' or right.action == action_name)
               	}
                     }
                     flash[:notice] = 'You are not authorized to view the page you requested'
                     #request.env['HTTP_REFERER'] ? (redirect_to :back) : (redirect_to :controller => 'login')
                     redirect_to :controller => 'main', :action => 'login'
                     return false
                   end
                 end
                 def verify_time_limit
                   return true if session[:user_id]==nil
                   user = User.find(session[:user_id], :include => :site)
                   return true if user==nil or user.site == nil
                   if user.contest_finished?
                     flash[:notice] = 'Error: the contest you are participating is over.'
                     redirect_to :back
                     return false
                   end
                   return true
                 end
               end

app/controllers/login_controller.rb ¶ +12

               class LoginController < ApplicationController
                 def index
                   # show login screen
                   reset_session
                   redirect_to :controller => 'main', :action => 'login'
                 end
                 def login
                   if user = User.authenticate(params[:login], params[:password])
                     session[:user_id] = user.id
                     session[:admin] = user.admin?
+            +
+            +       # clear forced logout flag for multicontests contest change
+            +       if Configuration.multicontests?
+            +         contest_stat = user.contest_stat
+            +         if contest_stat.respond_to? :forced_logout
+            +           if contest_stat.forced_logout
+            +             contest_stat.forced_logout = false
+            +             contest_stat.save
+            +           end
+            +         end
+            +       end
+            +
                     redirect_to :controller => 'main', :action => 'list'
                   else
                     flash[:notice] = 'Wrong password'
                     redirect_to :controller => 'main', :action => 'login'
                   end
                 end
                 def site_login
                   begin
                     site = Site.find(params[:login][:site_id])
                   rescue ActiveRecord::RecordNotFound
                     site = nil
                   end
                   if site==nil
                     flash[:notice] = 'Wrong site'
                     redirect_to :controller => 'main', :action => 'login'  and return
                   end
                   if (site.password) and (site.password == params[:login][:password])
                     session[:site_id] = site.id
                     redirect_to :controller => 'site', :action => 'index'
                   else
                     flash[:notice] = 'Wrong site password'
                     redirect_to :controller => 'site', :action => 'login'
                   end
                 end
               end

app/controllers/main_controller.rb ¶ +7

                       run = []
                       testrun = grading_info['testruns'][num]
                       testrun.each do |c|
                         run << read_grading_result(@user.login,
                                                    submission.problem.name,
                                                    submission.id,
                                                    c)
                       end
                       @test_runs << run
                     end
                   end
                 end
                 def grading_result_dir(user_name, problem_name, submission_id, case_num)
                   return "#{GRADING_RESULT_DIR}/#{user_name}/#{problem_name}/#{submission_id}/test-result/#{case_num}"
                 end
                 def output_filename(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   return "#{dir}/output.txt"
                 end
                 def read_grading_result(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   result_file_name = "#{dir}/result"
                   if !FileTest.exists?(result_file_name)
                     return {:num => case_num, :msg => 'program did not run'}
                   else
                     results = File.open(result_file_name).readlines
                     run_stat = extract_running_stat(results)
                     output_filename = "#{dir}/output.txt"
                     if FileTest.exists?(output_filename)
                       output_file = true
                       output_size = File.size(output_filename)
                     else
                       output_file = false
                       output_size = 0
                     end
                     return {
                       :num => case_num,
                       :msg => results[0],
                       :run_stat => run_stat,
                       :output => output_file,
                       :output_size => output_size
                     }
                   end
                 end
                 # copied from grader/script/lib/test_request_helper.rb
                 def extract_running_stat(results)
                   running_stat_line = results[-1]
                   # extract exit status line
                   run_stat = ""
                   if !(/[Cc]orrect/.match(results[0]))
                     run_stat = results[0].chomp
                   else
                     run_stat = 'Program exited normally'
                   end
                   logger.info "Stat line: #{running_stat_line}"
                   # extract running time
                   if res = /r(.*)u(.*)s/.match(running_stat_line)
                     seconds = (res[1].to_f + res[2].to_f)
                     time_stat = "Time used: #{seconds} sec."
                   else
                     seconds = nil
                     time_stat = "Time used: n/a sec."
                   end
                   # extract memory usage
                   if res = /s(.*)m/.match(running_stat_line)
                     memory_used = res[1].to_i
                   else
                     memory_used = -1
                   end
                   return {
                     :msg => "#{run_stat}\n#{time_stat}",
                     :running_time => seconds,
                     :exit_status => run_stat,
                     :memory_usage => memory_used
                   }
                 end
                 def update_user_start_time
                   user = User.find(session[:user_id])
                   user.update_start_time
                 end
                 def reject_announcement_refresh_when_logged_out
                   if not session[:user_id]
                     render :text => 'Access forbidden', :status => 403
                   end
+            +
+            +     if Configuration.multicontests?
+            +       user = User.find(session[:user_id])
+            +       if user.contest_stat.forced_logout
+            +         render :text => 'Access forbidden', :status => 403
+            +       end
+            +     end
                 end
               end

app/controllers/user_admin_controller.rb ¶ +13 -9

                     render :action => 'edit'
                   end
                 end
                 def destroy
                   User.find(params[:id]).destroy
                   redirect_to :action => 'list'
                 end
                 def user_stat
                   @problems = Problem.find_available_problems
                   @users = User.find(:all)
                   @scorearray = Array.new
                   @users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     @problems.each do |p|
               	sub = Submission.find_last_by_user_and_problem(u.id,p.id)
               	if (sub!=nil) and (sub.points!=nil)
               	  ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
               	else
               	  ustat << [0,false]
               	end
                     end
                     @scorearray << ustat
                   end
                 end
                 def import
                   if params[:file]==''
                     flash[:notice] = 'Error importing no file'
                     redirect_to :action => 'list' and return
                   end
                   import_from_file(params[:file])
                 end
                 def random_all_passwords
                   users = User.find(:all)
                   @prefix = params[:prefix] || ''
                   @non_admin_users = User.find_non_admin_with_prefix(@prefix)
                   @changed = false
                   if request.request_method == :post
                     @non_admin_users.each do |user|
                       password = random_password
                       user.password = password
                       user.password_confirmation = password
                       user.save
                     end
                     @changed = true
                   end
                 end
                 # contest management
                 def add_to_contest
                   user = User.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if user and contest
                     user.contests << contest
                   end
                   redirect_to :action => 'list'
                 end
                 def remove_from_contest
                   user = User.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if user and contest
                     user.contests.delete(contest)
                   end
                   redirect_to :action => 'list'
                 end
                 def contest_management
                 end
                 def manage_contest
                   contest = Contest.find(params[:contest][:id])
                   if !contest
                     flash[:notice] = 'You did not choose the contest.'
                     redirect_to :action => 'contest_management' and return
                   end
                   operation = params[:operation]
                   if not ['add','remove','assign'].include? operation
                     flash[:notice] = 'You did not choose the operation to perform.'
                     redirect_to :action => 'contest_management' and return
                   end
                   lines = params[:login_list]
                   if !lines or lines.blank?
                     flash[:notice] = 'You entered an empty list.'
                     redirect_to :action => 'contest_management' and return
                   end
                   note = []
-            -     user_ids = {}
+            +     users = []
                   lines.split("\n").each do |line|
                     user = User.find_by_login(line.chomp)
                     if user
                       if operation=='add'
                         if ! user.contests.include? contest
                           user.contests << contest
                         end
                       elsif operation=='remove'
                         user.contests.delete(contest)
                       else
                         user.contests = [contest]
                       end
-            -         user.contest_stat.destroy if params[:reset_timer]
+            +         if params[:reset_timer]
+            +           user.contest_stat.forced_logout = true
+            +           user.contest_stat.reset_timer_and_save
+            +         end
                       note << user.login
-            -         user_ids[user.id] = true
+            +         users << user
                     end
                   end
                   if params[:reset_timer]
-            -       logout_users(user_ids)
+            +       logout_users(users)
                   end
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     ' were successfully modified.  '
                   redirect_to :action => 'contest_management'
                 end
                 # admin management
                 def admin
                   @admins = User.find(:all).find_all {|user| user.admin? }
                 end
                 def grant_admin
                   login = params[:login]
                   user = User.find_by_login(login)
                   if user!=nil
                     admin_role = Role.find_by_name('admin')
                     user.roles << admin_role
                   else
                     flash[:notice] = 'Unknown user'
                   end
                   flash[:notice] = 'User added as admins'
                   redirect_to :action => 'admin'
                 end
                 def revoke_admin
                   user = User.find(params[:id])
                   if user==nil
                     flash[:notice] = 'Unknown user'
                     redirect_to :action => 'admin' and return
                   elsif user.login == 'root'
                     flash[:notice] = 'You cannot revoke admisnistrator permission from root.'
                     redirect_to :action => 'admin' and return
                   end
                   admin_role = Role.find_by_name('admin')
                   user.roles.delete(admin_role)
                   flash[:notice] = 'User permission revoked'
                   redirect_to :action => 'admin'
                 end
                 protected
                 def random_password(length=5)
                   chars = 'abcdefghijkmnopqrstuvwxyz23456789'
                   newpass = ""
                   length.times { newpass << chars[rand(chars.size-1)] }
                   return newpass
                 end
                 def import_from_file(f)
                   data_hash = YAML.load(f)
                   @import_log = ""
                   country_data = data_hash[:countries]
                   site_data = data_hash[:sites]
                   user_data = data_hash[:users]
                   # import country
                   countries = {}
                   country_data.each_pair do |id,country|
                     c = Country.find_by_name(country[:name])
                     if c!=nil
                       countries[id] = c
                       @import_log << "Found #{country[:name]}\n"
                     else
                       countries[id] = Country.new(:name => country[:name])
                       countries[id].save
                       @import_log << "Created #{country[:name]}\n"
                     end
                   end
                   # import sites
                   sites = {}
                   site_data.each_pair do |id,site|
                     s = Site.find_by_name(site[:name])
                     if s!=nil
                       @import_log << "Found #{site[:name]}\n"
                     else
                       s = Site.new(:name => site[:name])
                       @import_log << "Created #{site[:name]}\n"
                     end
                     s.password = site[:password]
                     s.country = countries[site[:country_id]]
                     s.save
                     sites[id] = s
                   end
                   # import users
                   user_data.each_pair do |id,user|
                     u = User.find_by_login(user[:login])
                     if u!=nil
                       @import_log << "Found #{user[:login]}\n"
                     else
                       u = User.new(:login => user[:login])
                       @import_log << "Created #{user[:login]}\n"
                     end
                     u.full_name = user[:name]
                     u.password = user[:password]
                     u.country = countries[user[:country_id]]
                     u.site = sites[user[:site_id]]
                     u.activated = true
                     u.email = "empty-#{u.login}@none.com"
                     if not u.save
                       @import_log << "Errors\n"
                       u.errors.each { |attr,msg|  @import_log << "#{attr} - #{msg}\n" }
                     end
                   end
                 end
-            -   def logout_users(user_ids)
+            +   def logout_users(users)
-            -     sessions = ActiveRecord::SessionStore::Session.find(:all, :conditions => ["updated_at >= ?", 60.minutes.ago])
+            +     users.each do |user|
-            -     sessions.each do |session|
+            +       contest_stat = user.contest_stat(true)
-            -       if user_ids.has_key? session.data[:user_id]
+            +       if contest_stat and !contest_stat.forced_logout
-            -         session.destroy
+            +         contest_stat.forced_logout = true
+            +         contest_stat.save
                     end
                   end
                 end
               end

app/models/user.rb ¶ +4 -4

                 validates_format_of :email,
                                     :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i,
                                     :if => :email_validation?
                 validate :uniqueness_of_email_from_activated_users,
                          :if => :email_validation?
                 validate :enough_time_interval_between_same_email_registrations,
                          :if => :email_validation?
                 # these are for ytopc
                 # disable for now
                 #validates_presence_of :province
                 attr_accessor :password
                 before_save :encrypt_new_password
                 before_save :assign_default_site
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   return user if user && user.authenticated?(password)
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def admin?
                   self.roles.detect {|r| r.name == 'admin' }
                 end
                 def email_for_editing
                   if self.email==nil
                     "(unknown)"
                   elsif self.email==''
                     "(blank)"
                   else
                     self.email
                   end
                 end
                 def email_for_editing=(e)
                   self.email=e
                 end
                 def alias_for_editing
                   if self.alias==nil
                     "(unknown)"
                   elsif self.alias==''
                     "(blank)"
                   else
                     self.alias
                   end
                 end
                 def alias_for_editing=(e)
                   self.alias=e
                 end
                 def activation_key
                   if self.hashed_password==nil
                     encrypt_new_password
                   end
                   Digest::SHA1.hexdigest(self.hashed_password)[0..7]
                 end
                 def verify_activation_key(key)
                   key == activation_key
                 end
                 def self.random_password(length=5)
                   chars = 'abcdefghjkmnopqrstuvwxyz'
                   password = ''
                   length.times { password << chars[rand(chars.length - 1)] }
                   password
                 end
                 def self.find_non_admin_with_prefix(prefix='')
                   users = User.find(:all)
                   return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
                 end
                 # Contest information
                 def contest_time_left
                   if Configuration.contest_mode?
                     return nil if site==nil
                     return site.time_left
                   elsif Configuration.indv_contest_mode?
                     time_limit = Configuration.contest_time_limit
                     if time_limit == nil
                       return nil
                     end
-            -       if contest_stat==nil
+            +       if contest_stat==nil or contest_stat.started_at==nil
                       return (Time.now.gmtime + time_limit) - Time.now.gmtime
                     else
                       finish_time = contest_stat.started_at + time_limit
                       current_time = Time.now.gmtime
                       if current_time > finish_time
                         return 0
                       else
                         return finish_time - current_time
                       end
                     end
                   else
                     return nil
                   end
                 end
                 def contest_finished?
                   if Configuration.contest_mode?
                     return false if site==nil
                     return site.finished?
                   elsif Configuration.indv_contest_mode?
                     return false if self.contest_stat(true)==nil
                     return contest_time_left == 0
                   else
                     return false
                   end
                 end
                 def contest_started?
                   if Configuration.contest_mode?
                     return true if site==nil
                     return site.started
                   else
                     return true
                   end
                 end
                 def update_start_time
                   stat = self.contest_stat
-            -     if stat == nil
+            +     if stat == nil or stat.started_at == nil
-            -       stat = UserContestStat.new(:user => self,
+            +       stat ||= UserContestStat.new(:user => self)
-            -                                  :started_at => Time.now.gmtime)
+            +       stat.started_at = Time.now.gmtime
                     stat.save
                   end
                 end
                 def problem_in_user_contests?(problem)
                   problem_contests = problem.contests.all
                   if problem_contests.length == 0   # this is public contest
                     return true
                   end
                   contests.each do |contest|
                     if problem_contests.find {|c| c.id == contest.id }
                       return true
                     end
                   end
                   return false
                 end
                 def available_problems_group_by_contests
                   contest_problems = []
                   pin = {}
                   contests.enabled.each do |contest|
                     available_problems = contest.problems.available
                     contest_problems << {
                       :contest => contest,
                       :problems => available_problems
                     }
                     available_problems.each {|p| pin[p.id] = true}
                   end
                   other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
                   contest_problems << {
                     :contest => nil,
                     :problems => other_avaiable_problems
                   }
                   return contest_problems
                 end
                 def available_problems
                   if not Configuration.multicontests?
                     return Problem.find_available_problems
                   else
                     contest_problems = []
                     pin = {}
                     contests.enabled.each do |contest|
                       contest.problems.available.each do |problem|
                         if not pin.has_key? problem.id
                           contest_problems << problem
                         end
                         pin[problem.id] = true
                       end
                     end
                     other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
                     return contest_problems + other_avaiable_problems
                   end
                 end
                 def can_view_problem?(problem)
                   if not Configuration.multicontests?
                     return problem.available
                   else
                     return problem_in_user_contests? problem
                   end
                 end
                 protected
                   def encrypt_new_password
                     return if password.blank?
                     self.salt = (10+rand(90)).to_s
                     self.hashed_password = User.encrypt(self.password,self.salt)
                   end
                   def assign_default_site
                     # have to catch error when migrating (because self.site is not available).
                     begin
                       if self.site==nil
                         self.site = Site.find_by_name('default')
                         if self.site==nil
                           self.site = Site.find(1)  # when 'default has be renamed'
                         end
                       end
                     rescue
                     end
                   end
                   def password_required?
                     self.hashed_password.blank? || !self.password.blank?
                   end
                   def self.encrypt(string,salt)
                     Digest::SHA1.hexdigest(salt + string)
                   end
                   def uniqueness_of_email_from_activated_users
                     user = User.activated_users.find_by_email(self.email)
                     if user and (user.login != self.login)

app/models/user_contest_stat.rb ¶ +5

               class UserContestStat < ActiveRecord::Base
                 belongs_to :user
+            +   def reset_timer_and_save
+            +     self.started_at = nil
+            +     save
+            +   end
+            +
               end

db/schema.rb ¶ +2 -1

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

public/javascripts/announcement_refresh.js ¶ +3 -2

               var Announcement = {
                   mostRecentId: 0,
                   refreshUrl: '/main/announcements',
                   setMostRecentId: function(id) {
               	Announcement.mostRecentId = id;
                   },
                   updateRecentId: function(id) {
               	if(Announcement.mostRecentId < id)
               	    Announcement.mostRecentId = id;
                   },
                   refreshAnnouncement: function() {
               	var url = Announcement.refreshUrl;
               	new Ajax.Request(url, {
               	    method: 'get',
               	    parameters: { recent: Announcement.mostRecentId },
               	    onSuccess: function(transport) {
-            - 		if(transport.responseText.match(/\S/)!=null) {
+            + 		if((transport.status == 200) &&
+            + 		   (transport.responseText.match(/\S/)!=null)) {
                		    var announcementBody = $("announcementbox-body");
               		    announcementBody.insert({ top: transport.responseText });
               		    var announcementBoxes = $$(".announcementbox");
               		    if(announcementBoxes.length!=0)
               			announcementBoxes[0].show();
+            + 		    Announcement.registerRefreshEventTimer();
               		}
               	    }
               	});
-            - 	Announcement.registerRefreshEventTimer();
                   },
                   registerRefreshEventTimer: function() {
               	setTimeout(function () {
               	    Announcement.refreshAnnouncement();
               	}, 30000);
                   }
               };

spec/integration/contest_managements_spec.rb ¶ +30

               require 'spec_helper'
               require 'config_spec_helper'
               require 'delorean'
               describe "ContestManagements" do
                 include ConfigSpecHelperMethods
                 fixtures :users
                 fixtures :problems
                 fixtures :contests
                 fixtures :roles
                 before(:each) do
                   @admin_user = users(:mary)
                   @contest_b = contests(:contest_b)
                   @james = users(:james)
                   @jack = users(:jack)
                   set_contest_time_limit('3:00')
                   set_indv_contest_mode
+            +     enable_multicontest
                 end
                 it "should reset users' timer when their contests change" do
                   james_session = open_session
                   james_session.extend(MainSessionMethods)
                   james_login_and_get_main_list(james_session)
                   james_session.response.should_not have_text(/OVER/)
                   Delorean.time_travel_to(190.minutes.since) do
                     james_session.get_main_list
                     james_session.response.should have_text(/OVER/)
                     james_session.get '/'                   # logout
                     james_session.get '/main/list'          # clearly log out
                     james_session.response.should_not render_template 'main/list'
                     admin_change_users_contest_to("james", @contest_b, true)
                     james_login_and_get_main_list(james_session)
                     james_session.response.should_not have_text(/OVER/)
                   end
                 end
+            +   it "should force users to log out when their contests change" do
+            +     james_session = open_session
+            +     james_session.extend(MainSessionMethods)
+            +
+            +     james_login_and_get_main_list(james_session)
+            +     james_session.response.should_not have_text(/OVER/)
+            +
+            +     Delorean.time_travel_to(190.minutes.since) do
+            +       james_session.get_main_list
+            +       james_session.response.should have_text(/OVER/)
+            +
+            +       admin_change_users_contest_to("james", @contest_b, true)
+            +
+            +       james_session.get '/main/list'
+            +       james_session.response.should_not render_template 'main/list'
+            +       james_session.should be_redirect
+            +
+            +       Delorean.time_travel_to(200.minutes.since) do
+            +         james_login_and_get_main_list(james_session)
+            +         james_session.response.should_not have_text(/OVER/)
+            +       end
+            +     end
+            +   end
+            +
                 private
                 module MainSessionMethods
                   def login(login_name, password)
                     post '/login/login', :login => login_name, :password => password
                     assert_redirected_to '/main/list'
                   end
                   def get_main_list
                     get '/main/list'
                     assert_template 'main/list'
                   end
+            +
+            +     def get_main_list_and_assert_logout
+            +       get '/main/list'
+            +       assert_redirected_to '/main'
+            +     end
                 end
                 module ContestManagementSessionMethods
                   def change_users_contest_to(user_login_list, contest, reset_timer=false)
                     post_data = {
                       :contest => {:id => contest.id},
                       :operation => 'assign',
                       :login_list => user_login_list
                     }
                     post_data[:reset_timer] = true if reset_timer
                     post '/user_admin/manage_contest', post_data
                   end
                 end
                 def admin_change_users_contest_to(user_list, contest, reset_timer)
                   admin_session = open_session
                   admin_session.extend(MainSessionMethods)
                   admin_session.extend(ContestManagementSessionMethods)
                   admin_session.login('mary','goodbye')
                   admin_session.get '/main/list'
                   admin_session.change_users_contest_to(user_list, contest, reset_timer)
                 end
                 def james_login_and_get_main_list(session)
                   session.login('james', 'morning')
                   session.get_main_list
                 end
               end

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r295:4f81b9ab5d77 - Sun, 28 Mar 2010 14:31:57 - 11 files changed: 170 inserted, 18 deleted

Sign in to your account

Commit r295:4f81b9ab5d77 public

Author

r295:4f81b9ab5d77 - Sun, 28 Mar 2010 14:31:57 - 11 files changed: 170 inserted, 18 deleted

Commit `r295:4f81b9ab5d77` public