cafe-grader-web Commit - r618:45e8321629ae

cafe-grader-web

Commit `r618:45e8321629ae` public

parent | child

Description:

update models to satisfy rails 4

Commit status:

[Not Reviewed]

References:

toRails40

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r618:45e8321629ae - Wed, 30 Nov 2016 08:25:17 - 7 files changed: 12 inserted, 16 deleted

app/models/contest.rb ¶ +1 -1

               class Contest < ActiveRecord::Base
                 has_and_belongs_to_many :users
                 has_and_belongs_to_many :problems
-            -   scope :enabled, :conditions => {:enabled => true}
+            +   scope :enabled, -> { where(enabled: true) }
               end

app/models/login.rb ¶ -1

               class Login < ActiveRecord::Base
                 belongs_to :user
-            -   attr_accessible :ip_address, :logged_in_at, :user_id
               end

app/models/problem.rb ¶ +1 -1

               class Problem < ActiveRecord::Base
                 belongs_to :description
                 has_and_belongs_to_many :contests, :uniq => true
                 has_many :test_pairs, :dependent => :delete_all
                 has_many :testcases, :dependent => :destroy
                 validates_presence_of :name
-            -   validates_format_of :name, :with => /^\w+$/
+            +   validates_format_of :name, :with => /\A\w+\z/
                 validates_presence_of :full_name
                 scope :available, :conditions => {:available => true}
                 DEFAULT_TIME_LIMIT = 1
                 DEFAULT_MEMORY_LIMIT = 32
                 def self.find_available_problems
                   Problem.available.all(:order => "date_added DESC, name ASC")
                 end
                 def self.create_from_import_form_params(params, old_problem=nil)
                   org_problem = old_problem || Problem.new
                   import_params, problem = Problem.extract_params_and_check(params,
                                                                             org_problem)
                   if !problem.errors.empty?
                     return problem, 'Error importing'
                   end
                   problem.full_score = 100
                   problem.date_added = Time.new
                   problem.test_allowed = true
                   problem.output_only = false
                   problem.available = false
                   if not problem.save
                     return problem, 'Error importing'
                   end
                   import_to_db = params.has_key? :import_to_db
                   importer = TestdataImporter.new(problem)
                   if not importer.import_from_file(import_params[:file],
                                                    import_params[:time_limit],
                                                    import_params[:memory_limit],
                                                    import_params[:checker_name],
                                                    import_to_db)
                     problem.errors.add(:base,'Import error.')
                   end
                   return problem, importer.log_msg
                 end
                 def self.download_file_basedir
                   return "#{Rails.root}/data/tasks"
                 end
                 def get_submission_stat
                   result = Hash.new
                   #total number of submission
                   result[:total_sub] = Submission.where(problem_id: self.id).count
                   result[:attempted_user] = Submission.where(problem_id: self.id).group_by(:user_id)
                 end
                 def long_name
                   "[#{name}] #{full_name}"
                 end
                 protected
                 def self.to_i_or_default(st, default)
                   if st!=''
                     result = st.to_i
                   end
                   result ||= default
                 end
                 def self.to_f_or_default(st, default)
                   if st!=''
                     result = st.to_f
                   end
                   result ||= default
                 end
                 def self.extract_params_and_check(params, problem)
                   time_limit = Problem.to_f_or_default(params[:time_limit],
                                                        DEFAULT_TIME_LIMIT)
                   memory_limit = Problem.to_i_or_default(params[:memory_limit],
                                                          DEFAULT_MEMORY_LIMIT)
                   if time_limit<=0 or time_limit >60
                     problem.errors.add(:base,'Time limit out of range.')
                   end
                   if memory_limit==0 and params[:memory_limit]!='0'
                     problem.errors.add(:base,'Memory limit format errors.')
                   elsif memory_limit<=0 or memory_limit >512
                     problem.errors.add(:base,'Memory limit out of range.')
                   end
                   if params[:file]==nil or params[:file]==''
                     problem.errors.add(:base,'No testdata file.')
                   end
                   checker_name = 'text'
                   if ['text','float'].include? params[:checker]
                     checker_name = params[:checker]
                   end
                   file = params[:file]
                   if !problem.errors.empty?
                     return nil, problem
                   end
                   problem.name = params[:name]
                   if params[:full_name]!=''
                     problem.full_name = params[:full_name]
                   else
                     problem.full_name = params[:name]
                   end
                   return [{
                             :time_limit => time_limit,
                             :memory_limit => memory_limit,
                             :file => file,
                             :checker_name => checker_name
                           },
                           problem]
                 end
               end

app/models/submission_view_log.rb ¶ +1 -1

               class SubmissionViewLog < ActiveRecord::Base
-            -   attr_accessible :submission_id, :user_id
+            +   #attr_accessible :submission_id, :user_id
               end

app/models/test_request.rb ¶ +1 -2

               #
               # A TestRequest is a composition of submission with user's testdata.
               #
               # Note about TestRequest#problem: Usually, A TestRequest has to be
               #   associated with a problem, so that execution environment can be
               #   determined.  However, to be more flexible, we have to ensure that
               #   it works as well with problem=nil.  In this case, we shall provide
               #   a "default" execution environment for it.  This can be done
               #   seamlessly by using TestRequest#problem_name or
               #   TestRequest#name_of(problem) when retrieving the name of the
               #   problem: #name_of would return problem.name when problem!=nil and
               #   it would return "default" when problem=nil, #problem_name just
               #   call #name_of.
               #
               require 'fileutils'
               class TestRequest < Task
+            +   self.table_name = "test_requests"
-            -   set_table_name "test_requests"
                 belongs_to :user
                 belongs_to :problem
                 belongs_to :submission
                 validates_presence_of :submission
                 validate :must_have_valid_problem
                 def problem_name
                   TestRequest.name_of(self.problem)
                 end
                 def language
                   self.submission.language
                 end
                 def self.get_inqueue_and_change_status(status)
                   # since there will be only one grader grading TestRequest
                   # we do not need locking (hopefully)
                   test_request = TestRequest.find(:first,
                                                   :order => "created_at",
                                                   :conditions => {:status=> Task::STATUS_INQUEUE})
                   if test_request!=nil
                     test_request.status = status
                     test_request.save!
                   end
                   test_request
                 end
                 # interfacing with form
                 def self.new_from_form_params(user,params)
                   test_request = TestRequest.new
                   test_request.user = user
                   begin
                     problem = Problem.find(params[:problem_id])
                   rescue ActiveRecord::RecordNotFound
                     problem = nil
                   end
                   test_request.problem = problem
                   if problem!=nil
                     test_request.submission =
                       Submission.find_by_user_problem_number(user.id,
                                                              problem.id,
                                                              params[:submission_number])
                   else
                     test_request.submission = nil
                   end
                   # checks if the user submits any input file
                   if params[:input_file]==nil or params[:input_file]==""
                     test_request.errors.add(:base,"No input submitted.")
                     test_request.input_file_name = nil
                   else
                     test_request.input_file_name = save_input_file(params[:input_file], user, problem)
                     if test_request.input_file_name == nil
                       test_request.errors.adds(:base,"No input submitted.")
                     end
                     if params[:additional_file]!=nil and params[:additional_file]!=""
                       save_additional_file(params[:additional_file],
                                            "#{test_request.input_file_name}.files")
                     end
                   end
                   test_request.submitted_at = Time.new.gmtime
                   test_request.status_inqueue
                   test_request
                 end
                 protected
                 def self.name_of(problem)
                   if problem!=nil
                     problem.name
                   else
                     "default"
                   end
                 end
                 def self.random_input_file_name(user,problem)
                   problem_name = TestRequest.name_of(problem)
                   begin
                     tmpname = TEST_REQUEST_INPUT_FILE_DIR + "/#{user.login}/#{problem_name}/#{rand(10000)}"
                   end while File.exists?(tmpname)
                   tmpname
                 end
                 def self.save_input_file(tempfile, user, problem)
                   new_file_name = random_input_file_name(user,problem)
                   dirname = File.dirname(new_file_name)
                   FileUtils.mkdir_p(File.dirname(new_file_name)) if !File.exists?(dirname)
                   # when the user did not submit any file
                   return nil if tempfile==""
                   if tempfile.instance_of?(Tempfile)
                     tempfile.close
                     FileUtils.move(tempfile.path,new_file_name)
                   else
                     File.open(new_file_name, "wb") do |f|
                       f.write(tempfile.read)
                     end
                   end
                   new_file_name
                 end
                 def self.save_additional_file(tempfile,dir)
                   new_file_name = "#{dir}/#{tempfile.original_filename}"
                   dirname = File.dirname(new_file_name)
                   FileUtils.mkdir_p(File.dirname(new_file_name)) if !File.exists?(dirname)
                   # when the user did not submit any file
                   return nil if tempfile==""
                   if tempfile.instance_of?(Tempfile)
                     tempfile.close
                     FileUtils.move(tempfile.path,new_file_name)
                   else
                     File.open(new_file_name, "wb") do |f|
                       f.write(tempfile.read)
                     end
                   end
                   new_file_name
                 end
                 #
                 # validations
                 #
                 def must_have_valid_problem
                   if problem==nil
                     errors.add('problem',"must be specified.")
                   elsif (!problem.available) and (self.new_record?)
                     errors.add('problem',"must be valid.")
                   end
                 end
               end

app/models/testcase.rb ¶ +1 -1

               class Testcase < ActiveRecord::Base
                 belongs_to :problem
-            -   attr_accessible :group, :input, :num, :score, :sol
+            +   #attr_accessible :group, :input, :num, :score, :sol
               end

app/models/user.rb ¶ +7 -9

               require 'digest/sha1'
               require 'net/pop'
               require 'net/https'
               require 'net/http'
               require 'json'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
-            -   has_many :test_requests, :order => "submitted_at DESC"
+            +   has_many :test_requests, -> {order(submitted_at: DESC)}
-            -   has_many :messages,
+            +   has_many :messages, -> { order(created_at: DESC) },
                          :class_name => "Message",
-            -            :foreign_key => "sender_id",
+            +            :foreign_key => "sender_id"
-            -            :order => 'created_at DESC'
-            -   has_many :replied_messages,
+            +   has_many :replied_messages, -> { order(created_at: DESC) },
                          :class_name => "Message",
-            -            :foreign_key => "receiver_id",
+            +            :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'
+            +   has_and_belongs_to_many :contests, -> { order(:name); uniq}
-            -   scope :activated_users, :conditions => {:activated => true}
+            +   scope :activated_users, -> {where activated: true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /\A[\_A-Za-z0-9]+\z/
                 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
                 before_save :assign_default_contest
                 # this is for will_paginate
                 cattr_reader :per_page
                 @@per_page = 50
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   if user
                     return user if user.authenticated?(password)
                     if user.authenticated_by_cucas?(password) or user.authenticated_by_pop3?(password)
                       user.password = password
                       user.save
                       return user
                     end
                   end
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def authenticated_by_pop3?(password)
                   Net::POP3.enable_ssl
                   pop = Net::POP3.new('pops.it.chula.ac.th')
                   authen = true
                   begin
                     pop.start(login, password)
                     pop.finish
                     return true
                   rescue
                     return false
                   end
                 end
                 def authenticated_by_cucas?(password)
                   url = URI.parse('https://www.cas.chula.ac.th/cas/api/?q=studentAuthenticate')
                   appid = '41508763e340d5858c00f8c1a0f5a2bb'
                   appsecret ='d9cbb5863091dbe186fded85722a1e31'
                   post_args = {
                     'appid' => appid,
                     'appsecret' => appsecret,
                     'username' => login,
                     'password' => password
                   }
                   #simple call
                   begin
                     http = Net::HTTP.new('www.cas.chula.ac.th', 443)
                     http.use_ssl = true
                     http.verify_mode = OpenSSL::SSL::VERIFY_NONE
                     result = [ ]
                     http.start do |http|
                       req = Net::HTTP::Post.new('/cas/api/?q=studentAuthenticate')
                       param = "appid=#{appid}&appsecret=#{appsecret}&username=#{login}&password=#{password}"
                       resp = http.request(req,param)
                       result = JSON.parse resp.body
                     end
                     return true if result["type"] == "beanStudent"
                   rescue => e
                     return false
                   end
                   return false
                 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 self.find_users_with_no_contest()
                   users = User.find(:all)
                   return users.find_all { |u| u.contests.length == 0 }
                 end
                 def contest_time_left
                   if GraderConfiguration.contest_mode?
                     return nil if site==nil
                     return site.time_left
                   elsif GraderConfiguration.indv_contest_mode?
                     time_limit = GraderConfiguration.contest_time_limit
                     if time_limit == nil
                       return nil
                     end
                     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 GraderConfiguration.contest_mode?
                     return false if site==nil
                     return site.finished?
                   elsif GraderConfiguration.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 GraderConfiguration.indv_contest_mode?
                     stat = self.contest_stat
                     return ((stat != nil) and (stat.started_at != nil))
                   elsif GraderConfiguration.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? or stat.started_at.nil?
                     stat ||= UserContestStat.new(:user => self)
                     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 GraderConfiguration.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 GraderConfiguration.multicontests?
                     return problem.available
                   else
                     return problem_in_user_contests? problem
                   end
                 end
                 def self.clear_last_login
                   User.update_all(:last_ip => nil)
                 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 assign_default_contest
                     # have to catch error when migrating (because self.site is not available).
                     begin
                       if self.contests.length == 0
                         default_contest = Contest.find_by_name(GraderConfiguration['contest.default_contest_name'])
                         if default_contest
                           self.contests = [default_contest]
                         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(: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(: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

r618:45e8321629ae - Wed, 30 Nov 2016 08:25:17 - 7 files changed: 12 inserted, 16 deleted

Sign in to your account

Commit r618:45e8321629ae public

Author

r618:45e8321629ae - Wed, 30 Nov 2016 08:25:17 - 7 files changed: 12 inserted, 16 deleted

Commit `r618:45e8321629ae` public