cafe-grader-web Commit - r288:74436ad04ad0

cafe-grader-web

Commit `r288:74436ad04ad0` public

parent | child

Description:

controllers get available problems from current user

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

r288:74436ad04ad0 - Thu, 11 Mar 2010 08:18:40 - 3 files changed: 42 inserted, 45 deleted

app/controllers/main_controller.rb ¶ +3 -44

               class MainController < ApplicationController
                 before_filter :authenticate, :except => [:index, :login]
                 before_filter :check_viewability, :except => [:index, :login]
                 append_before_filter :update_user_start_time, :except => [:index, :login]
                 # to prevent log in box to be shown when user logged out of the
                 # system only in some tab
                 prepend_before_filter :reject_announcement_refresh_when_logged_out, :only => [:announcements]
                 # COMMENTED OUT: filter in each action instead
                 # before_filter :verify_time_limit, :only => [:submit]
                 verify :method => :post, :only => [:submit],
                        :redirect_to => { :action => :index }
                 # COMMENT OUT: only need when having high load
                 # caches_action :index, :login
                 # NOTE: This method is not actually needed, 'config/routes.rb' has
                 # assigned action login as a default action.
                 def index
                   redirect_to :action => 'login'
                 end
                 def login
                   saved_notice = flash[:notice]
                   reset_session
                   flash.now[:notice] = saved_notice
                   # EXPERIMENT:
                   # Hide login if in single user mode and the url does not
                   # explicitly specify /login
                   #
                   # logger.info "PATH: #{request.path}"
                   # if Configuration['system.single_user_mode'] and
                   #     request.path!='/main/login'
                   #   @hidelogin = true
                   # end
                   @announcements = Announcement.find_for_frontpage
                   render :action => 'login', :layout => 'empty'
                 end
                 def list
                   prepare_list_information
                 end
                 def help
                   @user = User.find(session[:user_id])
                 end
                 def submit
                   user = User.find(session[:user_id])
                   @submission = Submission.new(params[:submission])
                   @submission.user = user
                   @submission.language_id = 0
                   if (params['file']) and (params['file']!='')
                     @submission.source = params['file'].read
                     @submission.source_filename = params['file'].original_filename
                   end
                   @submission.submitted_at = Time.new.gmtime
                   if Configuration.time_limit_mode? and user.contest_finished?
                     @submission.errors.add_to_base "The contest is over."
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   if @submission.valid?
                     if @submission.save == false
               	flash[:notice] = 'Error saving your submission'
                     elsif Task.create(:submission_id => @submission.id,
                                       :status => Task::STATUS_INQUEUE) == false
               	flash[:notice] = 'Error adding your submission to task queue'
                     end
                   else
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   redirect_to :action => 'list'
                 end
                 def source
                   submission = Submission.find(params[:id])
                   if submission.user_id == session[:user_id]
                     send_data(submission.source,
               		{:filename => submission.download_filename,
                                 :type => 'text/plain'})
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def compiler_msg
                   @submission = Submission.find(params[:id])
                   if @submission.user_id == session[:user_id]
                     render :action => 'compiler_msg', :layout => 'empty'
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def submission
                   @user = User.find(session[:user_id])
-            -     @problems = Problem.find_available_problems
+            +     @problems = @user.available_problems
                   if params[:id]==nil
                     @problem = nil
                     @submissions = nil
                   else
                     @problem = Problem.find_by_name(params[:id])
                     if not @problem.available
                       redirect_to :action => 'list'
                       flash[:notice] = 'Error: submissions for that problem are not viewable.'
                       return
                     end
                     @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id)
                   end
                 end
                 def result
                   if !Configuration.show_grading_result
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   prepare_grading_result(@submission)
                 end
                 def load_output
                   if !Configuration.show_grading_result or params[:num]==nil
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   case_num = params[:num].to_i
                   out_filename = output_filename(@user.login,
                                                  @submission.problem.name,
                                                  @submission.id,
                                                  case_num)
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   response.headers['Content-Type'] = "application/force-download"
                   response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
                   response.headers["X-Sendfile"] = out_filename
                   response.headers['Content-length'] = File.size(out_filename)
                   render :nothing => true
                 end
                 def error
                   @user = User.find(session[:user_id])
                 end
                 # announcement refreshing and hiding methods
                 def announcements
                   if params.has_key? 'recent'
                     prepare_announcements(params[:recent])
                   else
                     prepare_announcements
                   end
                   render(:partial => 'announcement',
                          :collection => @announcements,
                          :locals => {:announcement_effect => true})
                 end
                 protected
                 def prepare_announcements(recent=nil)
                   if Configuration.show_tasks_to?(@user)
                     @announcements = Announcement.find_published(true)
                   else
                     @announcements = Announcement.find_published
                   end
                   if recent!=nil
                     recent_id = recent.to_i
                     @announcements = @announcements.find_all { |a| a.id > recent_id }
                   end
                 end
-            -   def problem_list_by_user_contests(user)
-            -     contest_problems = []
-            -     pin = {}
-            -     user.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 problem_list_for_user(user, contest_problems=nil)
-            -     if not Configuration.multicontests?
-            -       return Problem.find_available_problems
-            -     else
-            -       if contest_problems==nil
-            -         contest_problems = problem_list_by_user_contests(user)
-            -       end
-            -       problems = []
-            -       collected = {}
-            -       contest_problems.each do |cp|
-            -         cp[:problems].each do |problem|
-            -           if not collected[problem.id]
-            -             problems << problem
-            -             collected[problem.id] = true
-            -           end
-            -         end
-            -       end
-            -       return problems
-            -     end
-            -   end
                 def prepare_list_information
                   @user = User.find(session[:user_id])
                   if not Configuration.multicontests?
                     @problems = problem_list_for_user(@user)
                   else
-            -       @contest_problems = problem_list_by_user_contests(@user)
+            +       @contest_problems = @user.available_problems_group_by_contests
-            -       @problems = problem_list_for_user(@user, @contest_problems)
+            +       @problems = @user.available_problems
                   end
                   @prob_submissions = {}
                   @problems.each do |p|
                     sub = Submission.find_last_by_user_and_problem(@user.id,p.id)
                     if sub!=nil
                       @prob_submissions[p.id] = { :count => sub.number, :submission => sub }
                     else
                       @prob_submissions[p.id] = { :count => 0, :submission => nil }
                     end
                   end
                   prepare_announcements
                 end
                 def check_viewability
                   @user = User.find(session[:user_id])
                   if (!Configuration.show_tasks_to?(@user)) and
                       ((action_name=='submission') or (action_name=='submit'))
                     redirect_to :action => 'list' and return
                   end
                 end
                 def prepare_grading_result(submission)
                   if Configuration.task_grading_info.has_key? submission.problem.name
                     grading_info = Configuration.task_grading_info[submission.problem.name]
                   else
                     # guess task info from problem.full_score
                     cases = submission.problem.full_score / 10
                     grading_info = {
                       'testruns' => cases,
                       'testcases' => cases
                     }
                   end
                   @test_runs = []
                   if grading_info['testruns'].is_a? Integer
                     trun_count = grading_info['testruns']
                     trun_count.times do |i|
                       @test_runs << [ read_grading_result(@user.login,
                                                           submission.problem.name,
                                                           submission.id,
                                                           i+1) ]
                     end
                   else
                     grading_info['testruns'].keys.sort.each do |num|
                       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
                 end
               end

app/controllers/tasks_controller.rb ¶ +1 -1

               class TasksController < ApplicationController
                 before_filter :authenticate, :check_viewability
                 def index
                   redirect_to :action => 'list'
                 end
                 def list
-            -     @problems = Problem.find_available_problems
+            +     @problems = @user.available_problems
                 end
                 # this has contest-wide access control
                 def view
                   base_name = params[:file]
                   base_filename = File.basename("#{base_name}.#{params[:ext]}")
                   filename = "#{Problem.download_file_basedir}/#{base_filename}"
                   if !FileTest.exists?(filename)
                     redirect_to :action => 'index' and return
                   end
                   send_file_to_user(filename, base_filename)
                 end
                 # this has problem-level access control
                 def download
                   problem = Problem.find(params[:id])
                   if !problem or !problem.available or !@user.can_view_problem? problem
                     redirect_to :action => 'index' and return
                   end
                   base_name = params[:file]
                   base_filename = File.basename("#{base_name}.#{params[:ext]}")
                   filename = "#{Problem.download_file_basedir}/#{params[:id]}/#{base_filename}"
                   puts "SENDING: #{filename}"
                   if !FileTest.exists?(filename)
                     redirect_to :action => 'index' and return
                   end
                   puts "SENDING: #{filename}"
                   send_file_to_user(filename, base_filename)
                 end
                 protected
                 def send_file_to_user(filename, base_filename)
                   if defined?(USE_APACHE_XSENDFILE) and USE_APACHE_XSENDFILE
                     response.headers['Content-Type'] = "application/force-download"
                     response.headers['Content-Disposition'] = "attachment; filename=\"#{File.basename(filename)}\""
                     response.headers["X-Sendfile"] = filename
                     response.headers['Content-length'] = File.size(filename)
                     render :nothing => true
                   else
                     if params[:ext]=='pdf'
                       content_type = 'application/pdf'
                     else
                       content_type = 'application/octet-stream'
                     end
                     send_file filename, :stream => false, :filename => base_filename, :type => content_type
                   end
                 end
                 def check_viewability
                   @user = User.find(session[:user_id])
                   if @user==nil or !Configuration.show_tasks_to?(@user)
                     redirect_to :controller => 'main', :action => 'list'
                     return false
                   end
                 end
               end

app/models/user.rb ¶ +38

               require 'digest/sha1'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
                 has_many :test_requests, :order => "submitted_at DESC"
                 has_many :messages,
                          :class_name => "Message",
                          :foreign_key => "sender_id",
                          :order => 'created_at DESC'
                 has_many :replied_messages,
                          :class_name => "Message",
                          :foreign_key => "receiver_id",
                          :order => 'created_at DESC'
                 has_one :contest_stat, :class_name => "UserContestStat", :dependent => :destroy
                 belongs_to :site
                 belongs_to :country
                 has_and_belongs_to_many :contests, :uniq => true, :order => 'name'
                 named_scope :activated_users, :conditions => {:activated => true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /^[\_A-Za-z0-9]+$/
                 validates_length_of :login, :within => 3..30
                 validates_presence_of :full_name
                 validates_length_of :full_name, :minimum => 1
                 validates_presence_of :password, :if => :password_required?
                 validates_length_of :password, :within => 4..20, :if => :password_required?
                 validates_confirmation_of :password, :if => :password_required?
                 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
                       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?
                     time_limit = Configuration.contest_time_limit
                     return false if contest_stat==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
                     stat = UserContestStat.new(:user => self,
                                                :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)
                       self.errors.add_to_base("Email has already been taken")
                     end
                   end
                   def enough_time_interval_between_same_email_registrations
                     return if !self.new_record?
                     return if self.activated
                     open_user = User.find_by_email(self.email,
                                                    :order => 'created_at DESC')
                     if open_user and open_user.created_at and
                         (open_user.created_at > Time.now.gmtime - 5.minutes)
                       self.errors.add_to_base("There are already unactivated registrations with this e-mail address (please wait for 5 minutes)")
                     end
                   end
                   def email_validation?
                     begin
                       return VALIDATE_USER_EMAILS
                     rescue
                       return false
                     end
                   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

r288:74436ad04ad0 - Thu, 11 Mar 2010 08:18:40 - 3 files changed: 42 inserted, 45 deleted

Sign in to your account

Commit r288:74436ad04ad0 public

Author

r288:74436ad04ad0 - Thu, 11 Mar 2010 08:18:40 - 3 files changed: 42 inserted, 45 deleted

Commit `r288:74436ad04ad0` public