cafe-grader-web Commit - r619:35d86016ce86

cafe-grader-web

Commit `r619:35d86016ce86` public

parent | child

Description:

change find(:xxx) to correct syntax for 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

r619:35d86016ce86 - Tue, 06 Dec 2016 17:01:12 - 26 files changed: 108 inserted, 147 deleted

Gemfile ¶ +1 -1

               source 'https://rubygems.org'
-            - gem 'rails', '~>4.0.0'
+            + gem 'rails', '~>4.1.0'
               gem 'activerecord-session_store'
               gem 'select2-rails'
               # Bundle edge Rails instead:
               # gem 'rails', :git => 'git://github.com/rails/rails.git'
               gem 'mysql2', '~> 0.3.0'
               # Gems used only for assets and not required
               # in production environments by default.
               group :assets do
                 gem 'sass-rails'
                 gem 'coffee-rails'
                 # See https://github.com/sstephenson/execjs#readme for more supported runtimes
                 # gem 'therubyracer', :platforms => :ruby
                 gem 'uglifier'
               end
               # gem 'prototype-rails'
               # To use ActiveModel has_secure_password
               # gem 'bcrypt-ruby', '~> 3.0.0'
               # To use Jbuilder templates for JSON
               # gem 'jbuilder'
               # Use unicorn as the app server
               # gem 'unicorn'
               # Deploy with Capistrano
               # gem 'capistrano'
               # To use debugger
               # gem 'debugger'
               #
               #in-place editor
               gem 'best_in_place', '~> 3.0.1'
               # jquery addition
               gem 'jquery-rails'
               gem 'jquery-ui-sass-rails'
               gem 'jquery-timepicker-addon-rails'
               gem 'jquery-tablesorter'
               gem 'jquery-countdown-rails'

Gemfile.lock ¶ +48 -42

               GIT
                 remote: https://github.com/sikachu/verification.git
                 revision: e6fe084ce16b7b5a4b1cdfca5374d125fd034a0f
                 specs:
                   verification (1.0.3)
                     actionpack (>= 3.0.0, < 5.0)
                     activesupport (>= 3.0.0, < 5.0)
               GEM
                 remote: https://rubygems.org/
                 specs:
                   ace-rails-ap (4.1.1)
-            -     actionmailer (4.0.13)
+            +     actionmailer (4.1.16)
-            -       actionpack (= 4.0.13)
+            +       actionpack (= 4.1.16)
+            +       actionview (= 4.1.16)
                     mail (~> 2.5, >= 2.5.4)
-            -     actionpack (4.0.13)
+            +     actionpack (4.1.16)
-            -       activesupport (= 4.0.13)
+            +       actionview (= 4.1.16)
-            -       builder (~> 3.1.0)
+            +       activesupport (= 4.1.16)
-            -       erubis (~> 2.7.0)
                     rack (~> 1.5.2)
                     rack-test (~> 0.6.2)
-            -     activemodel (4.0.13)
+            +     actionview (4.1.16)
-            -       activesupport (= 4.0.13)
+            +       activesupport (= 4.1.16)
-            -       builder (~> 3.1.0)
+            +       builder (~> 3.1)
-            -     activerecord (4.0.13)
+            +       erubis (~> 2.7.0)
-            -       activemodel (= 4.0.13)
+            +     activemodel (4.1.16)
-            -       activerecord-deprecated_finders (~> 1.0.2)
+            +       activesupport (= 4.1.16)
-            -       activesupport (= 4.0.13)
+            +       builder (~> 3.1)
-            -       arel (~> 4.0.0)
+            +     activerecord (4.1.16)
-            -     activerecord-deprecated_finders (1.0.4)
+            +       activemodel (= 4.1.16)
+            +       activesupport (= 4.1.16)
+            +       arel (~> 5.0.0)
                   activerecord-session_store (1.0.0)
                     actionpack (>= 4.0, < 5.1)
                     activerecord (>= 4.0, < 5.1)
                     multi_json (~> 1.11, >= 1.11.2)
                     rack (>= 1.5.2, < 3)
                     railties (>= 4.0, < 5.1)
-            -     activesupport (4.0.13)
+            +     activesupport (4.1.16)
                     i18n (~> 0.6, >= 0.6.9)
-            -       minitest (~> 4.2)
+            +       json (~> 1.7, >= 1.7.7)
-            -       multi_json (~> 1.3)
+            +       minitest (~> 5.1)
                     thread_safe (~> 0.1)
-            -       tzinfo (~> 0.3.37)
+            +       tzinfo (~> 1.1)
-            -     arel (4.0.2)
+            +     arel (5.0.1.20140414130214)
-            -     autoprefixer-rails (6.5.2)
+            +     autoprefixer-rails (6.5.3.1)
                     execjs
                   best_in_place (3.0.3)
                     actionpack (>= 3.2)
                     railties (>= 3.2)
                   bootstrap-sass (3.2.0.2)
                     sass (~> 3.2)
                   bootstrap-switch-rails (3.3.3)
                   bootstrap-toggle-rails (2.2.1.0)
-            -     builder (3.1.4)
+            +     builder (3.2.2)
                   coffee-rails (4.2.1)
                     coffee-script (>= 2.2.0)
                     railties (>= 4.0.0, < 5.2.x)
                   coffee-script (2.4.1)
                     coffee-script-source
                     execjs
-            -     coffee-script-source (1.10.0)
+            +     coffee-script-source (1.11.1)
                   concurrent-ruby (1.0.2)
                   diff-lcs (1.2.5)
                   dynamic_form (1.1.4)
                   erubis (2.7.0)
                   execjs (2.7.0)
                   haml (4.0.7)
                     tilt
                   haml-rails (0.9.0)
                     actionpack (>= 4.0.1)
                     activesupport (>= 4.0.1)
                     haml (>= 4.0.6, < 5.0)
                     html2haml (>= 1.0.1)
                     railties (>= 4.0.1)
                   html2haml (2.0.0)
                     erubis (~> 2.7.0)
                     haml (~> 4.0.0)
                     nokogiri (~> 1.6.0)
                     ruby_parser (~> 3.5)
                   i18n (0.7.0)
                   in_place_editing (1.2.0)
                   jquery-countdown-rails (2.0.2)
                   jquery-rails (3.1.4)
                     railties (>= 3.0, < 5.0)
                     thor (>= 0.14, < 2.0)
-            -     jquery-tablesorter (1.22.7)
+            +     jquery-tablesorter (1.23.1)
                     railties (>= 3.2, < 6)
                   jquery-timepicker-addon-rails (1.4.1)
                     railties (>= 3.1)
                   jquery-ui-rails (4.0.3)
                     jquery-rails
                     railties (>= 3.1.0)
                   jquery-ui-sass-rails (4.0.3.0)
                     jquery-rails
                     jquery-ui-rails (= 4.0.3)
                     railties (>= 3.1.0)
+            +     json (1.8.3)
                   mail (2.6.4)
                     mime-types (>= 1.16, < 4)
                   mime-types (3.1)
                     mime-types-data (~> 3.2015)
                   mime-types-data (3.2016.0521)
                   mini_portile2 (2.1.0)
-            -     minitest (4.7.5)
+            +     minitest (5.10.1)
                   momentjs-rails (2.15.1)
                     railties (>= 3.1)
                   multi_json (1.12.1)
                   mysql2 (0.3.21)
                   nokogiri (1.6.8.1)
                     mini_portile2 (~> 2.1.0)
-            -     power_assert (0.3.1)
+            +     power_assert (0.4.1)
                   rack (1.5.5)
                   rack-test (0.6.3)
                     rack (>= 1.0)
-            -     rails (4.0.13)
+            +     rails (4.1.16)
-            -       actionmailer (= 4.0.13)
+            +       actionmailer (= 4.1.16)
-            -       actionpack (= 4.0.13)
+            +       actionpack (= 4.1.16)
-            -       activerecord (= 4.0.13)
+            +       actionview (= 4.1.16)
-            -       activesupport (= 4.0.13)
+            +       activemodel (= 4.1.16)
+            +       activerecord (= 4.1.16)
+            +       activesupport (= 4.1.16)
                     bundler (>= 1.3.0, < 2.0)
-            -       railties (= 4.0.13)
+            +       railties (= 4.1.16)
                     sprockets-rails (~> 2.0)
                   rails_bootstrap_sortable (2.0.1)
                     momentjs-rails (>= 2.8.3)
-            -     railties (4.0.13)
+            +     railties (4.1.16)
-            -       actionpack (= 4.0.13)
+            +       actionpack (= 4.1.16)
-            -       activesupport (= 4.0.13)
+            +       activesupport (= 4.1.16)
                     rake (>= 0.8.7)
                     thor (>= 0.18.1, < 2.0)
-            -     rake (11.3.0)
+            +     rake (12.0.0)
                   rdiscount (2.2.0.1)
-            -     rouge (2.0.6)
+            +     rouge (2.0.7)
                   rspec-collection_matchers (1.1.2)
                     rspec-expectations (>= 2.99.0.beta1)
                   rspec-core (2.99.2)
                   rspec-expectations (2.99.2)
                     diff-lcs (>= 1.1.3, < 2.0)
                   rspec-mocks (2.99.4)
                   rspec-rails (2.99.0)
                     actionpack (>= 3.0)
                     activemodel (>= 3.0)
                     activesupport (>= 3.0)
                     railties (>= 3.0)
                     rspec-collection_matchers
                     rspec-core (~> 2.99.0)
                     rspec-expectations (~> 2.99.0)
                     rspec-mocks (~> 2.99.0)
                   ruby_parser (3.8.3)
                     sexp_processor (~> 4.1)
                   sass (3.4.22)
                   sass-rails (5.0.6)
                     railties (>= 4.0.0, < 6)
                     sass (~> 3.1)
                     sprockets (>= 2.8, < 4.0)
                     sprockets-rails (>= 2.0, < 4.0)
                     tilt (>= 1.1, < 3)
                   select2-rails (4.0.3)
                     thor (~> 0.14)
                   sexp_processor (4.7.0)
                   sprockets (3.7.0)
                     concurrent-ruby (~> 1.0)
                     rack (> 1, < 3)
                   sprockets-rails (2.3.3)
                     actionpack (>= 3.0)
                     activesupport (>= 3.0)
                     sprockets (>= 2.8, < 4.0)
-            -     test-unit (3.2.2)
+            +     test-unit (3.2.3)
                     power_assert
-            -     thor (0.19.1)
+            +     thor (0.19.4)
                   thread_safe (0.3.5)
                   tilt (2.0.5)
-            -     tzinfo (0.3.52)
+            +     tzinfo (1.2.2)
-            -     uglifier (3.0.3)
+            +       thread_safe (~> 0.1)
+            +     uglifier (3.0.4)
                     execjs (>= 0.3.0, < 3)
                   will_paginate (3.0.12)
               PLATFORMS
                 ruby
               DEPENDENCIES
                 ace-rails-ap
                 activerecord-session_store
                 autoprefixer-rails
                 best_in_place (~> 3.0.1)
                 bootstrap-sass (~> 3.2.0)
                 bootstrap-switch-rails
                 bootstrap-toggle-rails
                 coffee-rails
                 dynamic_form
                 haml
                 haml-rails
                 in_place_editing
                 jquery-countdown-rails
                 jquery-rails
                 jquery-tablesorter
                 jquery-timepicker-addon-rails
                 jquery-ui-sass-rails
                 mail
                 momentjs-rails
                 mysql2 (~> 0.3.0)
-            -   rails (~> 4.0.0)
+            +   rails (~> 4.1.0)
                 rails_bootstrap_sortable
                 rdiscount
                 rouge
                 rspec-rails (~> 2.99.0)
                 sass-rails
                 select2-rails
                 test-unit
                 uglifier
                 verification!
                 will_paginate (~> 3.0.7)
               BUNDLED WITH
 .13.6

app/controllers/announcements_controller.rb ¶ +1 -2

               class AnnouncementsController < ApplicationController
                 before_filter :admin_authorization
                 in_place_edit_for :announcement, :published
                 # GET /announcements
                 # GET /announcements.xml
                 def index
-            -     @announcements = Announcement.find(:all,
+            +     @announcements = Announcement.order(created_at: :desc)
-            -                                        :order => "created_at DESC")
                   respond_to do |format|
                     format.html # index.html.erb
                     format.xml  { render :xml => @announcements }
                   end
                 end
                 # GET /announcements/1
                 # GET /announcements/1.xml
                 def show
                   @announcement = Announcement.find(params[:id])
                   respond_to do |format|
                     format.html # show.html.erb
                     format.xml  { render :xml => @announcement }
                   end
                 end
                 # GET /announcements/new
                 # GET /announcements/new.xml
                 def new
                   @announcement = Announcement.new
                   respond_to do |format|
                     format.html # new.html.erb
                     format.xml  { render :xml => @announcement }
                   end
                 end
                 # GET /announcements/1/edit
                 def edit
                   @announcement = Announcement.find(params[:id])
                 end
                 # POST /announcements
                 # POST /announcements.xml
                 def create
                   @announcement = Announcement.new(params[:announcement])
                   respond_to do |format|
                     if @announcement.save
                       flash[:notice] = 'Announcement was successfully created.'
                       format.html { redirect_to(@announcement) }
                       format.xml  { render :xml => @announcement, :status => :created, :location => @announcement }
                     else
                       format.html { render :action => "new" }
                       format.xml  { render :xml => @announcement.errors, :status => :unprocessable_entity }
                     end

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

               class ApplicationController < ActionController::Base
                 protect_from_forgery
                 before_filter :current_user
                 SINGLE_USER_MODE_CONF_KEY = 'system.single_user_mode'
                 MULTIPLE_IP_LOGIN_CONF_KEY = 'right.multiple_ip_login'
                 #report and redirect for unauthorized activities
                 def unauthorized_redirect
                   flash[:notice] = 'You are not authorized to view the page you requested'
                   redirect_to :controller => 'main', :action => 'login'
                 end
                 # Returns the current logged-in user (if any).
                 def current_user
                   return nil unless session[:user_id]
                   @current_user ||= User.find(session[:user_id])
                 end
                 def admin_authorization
                   return false unless authenticate
-            -     user = User.find(session[:user_id], :include => ['roles'])
+            +     user = User.includes(:roles).find(session[:user_id])
                   unless user.admin?
                     unauthorized_redirect
                     return false
                   end
                   return true
                 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) }
                     unauthorized_redirect
                     return false
                   end
                 end
                 protected
                 def authenticate
                   unless session[:user_id]
                     flash[:notice] = 'You need to login'
                     if GraderConfiguration[SINGLE_USER_MODE_CONF_KEY]
                       flash[:notice] = 'You need to login but you cannot log in at this time'
                     end
                     redirect_to :controller => 'main', :action => 'login'
                     return false
                   end
                   # check if run in single user mode
                   if GraderConfiguration[SINGLE_USER_MODE_CONF_KEY]
                     user = User.find_by_id(session[:user_id])
                     if user==nil or (not user.admin?)
                       flash[:notice] = 'You cannot log in at this time'
                       redirect_to :controller => 'main', :action => 'login'
                       return false
                     end
                     unless user.enabled?
                       flash[:notice] = 'Your account is disabled'
                       redirect_to :controller => 'main', :action => 'login'
                       return false
                     end
                     return true
                   end
                   if GraderConfiguration.multicontests?
                     user = User.find(session[:user_id])
                     return true if user.admin?
                     begin

app/controllers/configurations_controller.rb ¶ +1 -2

               class ConfigurationsController < ApplicationController
                 before_filter :authenticate
                 before_filter { |controller| controller.authorization_by_roles(['admin'])}
                 def index
-            -     @configurations = GraderConfiguration.find(:all,
+            +     @configurations = GraderConfiguration.order(:key)
-            -                                          :order => '`key`')
                   @group = GraderConfiguration.pluck("grader_configurations.key").map{ |x| x[0...(x.index('.'))] }.uniq.sort
                 end
                 def reload
                   GraderConfiguration.reload
                   redirect_to :action => 'index'
                 end
                 def update
                   @config = GraderConfiguration.find(params[:id])
                   User.clear_last_login if @config.key == GraderConfiguration::MULTIPLE_IP_LOGIN_KEY and @config.value == 'true' and params[:grader_configuration][:value] == 'false'
                   respond_to do |format|
                     if @config.update_attributes(configuration_params)
                       format.json { head :ok }
                     else
                       format.json { respond_with_bip(@config) }
                     end
                   end
                 end
               private
                 def configuration_params
                   params.require(:grader_configuration).permit(:key,:value_type,:value,:description)
                 end
               end

app/controllers/contest_management_controller.rb ¶ +2 -2

               class ContestManagementController < ApplicationController
                 before_filter :admin_authorization
                 def index
                   @num_contests = Contest.count()
                 end
                 def user_stat
                   if not GraderConfiguration.indv_contest_mode?
                     redirect_to :action => 'index' and return
                   end
-            -     @users = User.find(:all)
+            +     @users = User.all
                   @start_times = {}
-            -     UserContestStat.find(:all).each do |stat|
+            +     UserContestStat.all.each do |stat|
                     @start_times[stat.user_id] = stat.started_at
                   end
                 end
                 def clear_stat
                   user = User.find(params[:id])
                   if user.contest_stat!=nil
                     user.contest_stat.destroy
                   end
                   redirect_to :action => 'user_stat'
                 end
                 def clear_all_stat
                   if not GraderConfiguration.indv_contest_mode?
                     redirect_to :action => 'index' and return
                   end
                   UserContestStat.delete_all()
                   flash[:notice] = 'All start time statistic cleared.'
                   redirect_to :action => 'index'
                 end
                 def change_contest_mode
                   if ['standard', 'contest', 'indv-contest', 'analysis'].include? params[:id]
                     config = GraderConfiguration.find_by_key('system.mode')
                     config.value = params[:id]
                     config.save
                   else
                     flash[:notice] = 'Wrong contest mode value'
                   end
                   redirect_to :action => 'index'
                 end
               end

app/controllers/graders_controller.rb ¶ +3 -5

               class GradersController < ApplicationController
                 before_filter :admin_authorization, except: [ :submission ]
                 before_filter(only: [:submission]) {
                   #check if authenticated
                   return false unless authenticate
                   #admin always has privileged
                   if @current_user.admin?
                     return true
                   end
                   if GraderConfiguration["right.user_view_submission"] and Submission.find(params[:id]).problem.available?
                     return true
                   else
                     unauthorized_redirect
                     return false
                   end
                 }
                 verify :method => :post, :only => ['clear_all',
                                                    'start_exam',
                                                    'start_grading',
                                                    'stop_all',
                                                    'clear_terminated'],
                        :redirect_to => {:action => 'index'}
                 def index
                   redirect_to :action => 'list'
                 end
                 def list
                   @grader_processes = GraderProcess.find_running_graders
                   @stalled_processes = GraderProcess.find_stalled_process
                   @terminated_processes = GraderProcess.find_terminated_graders
-            -     @last_task = Task.find(:first,
+            +     @last_task = Task.last
-            -                            :order => 'created_at DESC')
+            +     @last_test_request = TestRequest.last
-            -     @last_test_request = TestRequest.find(:first,
-            -                                           :order => 'created_at DESC')
                   @submission = Submission.order("id desc").limit(20)
                   @backlog_submission = Submission.where('graded_at is null')
                 end
                 def clear
                   grader_proc = GraderProcess.find(params[:id])
                   grader_proc.destroy if grader_proc!=nil
                   redirect_to :action => 'list'
                 end
                 def clear_terminated
                   GraderProcess.find_terminated_graders.each do |p|
                     p.destroy
                   end
                   redirect_to :action => 'list'
                 end
                 def clear_all
-            -     GraderProcess.find(:all).each do |p|
+            +     GraderProcess.all.each do |p|
                     p.destroy
                   end
                   redirect_to :action => 'list'
                 end
                 def view
                   if params[:type]=='Task'
                     redirect_to :action => 'task', :id => params[:id]
                   else
                     redirect_to :action => 'test_request', :id => params[:id]
                   end
                 end
                 def test_request
                   @test_request = TestRequest.find(params[:id])
                 end
                 def task
                   @task = Task.find(params[:id])
                 end
                 def submission
                   @submission = Submission.find(params[:id])
                   formatter = Rouge::Formatters::HTML.new(css_class: 'highlight', line_numbers: true )
                   lexer = case @submission.language.name
                     when "c"      then Rouge::Lexers::C.new
                     when "cpp"    then Rouge::Lexers::Cpp.new
                     when "pas"    then Rouge::Lexers::Pas.new
                     when "ruby"   then Rouge::Lexers::Ruby.new
                     when "python" then Rouge::Lexers::Python.new
                     when "java"   then Rouge::Lexers::Java.new
                     when "php"    then Rouge::Lexers::PHP.new
                   end
                   @formatted_code = formatter.format(lexer.lex(@submission.source))
                   @css_style = Rouge::Themes::ThankfulEyes.render(scope: '.highlight')
                   user = User.find(session[:user_id])
                   SubmissionViewLog.create(user_id: session[:user_id],submission_id: @submission.id) unless user.admin?
                 end
                 # various grader controls
                 def stop
                   grader_proc = GraderProcess.find(params[:id])
                   GraderScript.stop_grader(grader_proc.pid)
                   flash[:notice] = 'Grader stopped.  It may not disappear now, but it should disappear shortly.'
                   redirect_to :action => 'list'

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

               class MainController < ApplicationController
                 before_filter :authenticate, :except => [:index, :login]
                 before_filter :check_viewability, :except => [:index, :login]
                 append_before_filter :confirm_and_update_start_time,
                                      :except => [:index,
                                                  :login,
                                                  :confirm_contest_start]
                 # 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]
                 before_filter :authenticate_by_ip_address, :only => [:list]
                 # 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 GraderConfiguration['system.single_user_mode'] and
                   #     request.path!='/main/login'
                   #   @hidelogin = true
                   # end
-            -     @announcements = Announcement.find_for_frontpage
+            +     @announcements = Announcement.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
                   @submission.problem_id = params[:submission][:problem_id]
                   @submission.user = user
                   @submission.language_id = 0
                   if (params['file']) and (params['file']!='')
                     @submission.source = File.open(params['file'].path,'r:UTF-8',&:read)
                     @submission.source.encode!('UTF-8','UTF-8',invalid: :replace, replace: '')
                     @submission.source_filename = params['file'].original_filename
                   end
                   if (params[:editor_text])
                     language = Language.find_by_id(params[:language_id])
                     @submission.source = params[:editor_text]
                     @submission.source_filename = "live_edit.#{language.ext}"
                     @submission.language = language
                   end
                   @submission.submitted_at = Time.new.gmtime
                   @submission.ip_address = request.remote_ip
                   if GraderConfiguration.time_limit_mode? and user.contest_finished?
                     @submission.errors.add(: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
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   if defined?(USE_APACHE_XSENDFILE) and USE_APACHE_XSENDFILE
                     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
                   else
                     send_file out_filename, :stream => false, :filename => "output-#{case_num}.txt", :type => "text/plain"
                   end
                 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
                 def confirm_contest_start
                   user = User.find(session[:user_id])
                   if request.method == 'POST'
                     user.update_start_time
                     redirect_to :action => 'list'
                   else
                     @contests = user.contests
                     @user = user
                   end
                 end
                 protected
                 def prepare_announcements(recent=nil)
                   if GraderConfiguration.show_tasks_to?(@user)
-            -       @announcements = Announcement.find_published(true)
+            +       @announcements = Announcement.published(true)
                   else
-            -       @announcements = Announcement.find_published
+            +       @announcements = Announcement.published
                   end
                   if recent!=nil
                     recent_id = recent.to_i
                     @announcements = @announcements.find_all { |a| a.id > recent_id }
                   end
                 end
                 def prepare_list_information
                   @user = User.find(session[:user_id])
                   if not GraderConfiguration.multicontests?
                     @problems = @user.available_problems
                   else
                     @contest_problems = @user.available_problems_group_by_contests
                     @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 (!GraderConfiguration.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 GraderConfiguration.task_grading_info.has_key? submission.problem.name
                     grading_info = GraderConfiguration.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

app/controllers/problems_controller.rb ¶ +4 -6

               class ProblemsController < ApplicationController
                 before_filter :authenticate, :authorization
                 in_place_edit_for :problem, :name
                 in_place_edit_for :problem, :full_name
                 in_place_edit_for :problem, :full_score
                 def index
-            -     @problems = Problem.find(:all, :order => 'date_added DESC')
+            +     @problems = Problem.order(date_added: :desc)
                 end
                 # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
                 verify :method => :post, :only => [ :create, :quick_create,
                                                     :do_manage,
                                                     :do_import,
                                                   ],
                        :redirect_to => { :action => :index }
                 def show
                   @problem = Problem.find(params[:id])
                 end
                 def new
                   @problem = Problem.new
                   @description = nil
                 end
                 def create
                   @problem = Problem.new(params[:problem])
                   @description = Description.new(params[:description])
                   if @description.body!=''
                     if !@description.save
                       render :action => new and return
                     end
                   else
                     @description = nil
                   end
                   @problem.description = @description
                   if @problem.save
                     flash[:notice] = 'Problem was successfully created.'
                     redirect_to action: :index
                   else
                     render :action => 'new'
                   end
                 end
                 def quick_create
                   @problem = Problem.new(params[:problem])
                   @problem.full_name = @problem.name if @problem.full_name == ''
                   @problem.full_score = 100
                   @problem.available = false
                   @problem.test_allowed = true
                   @problem.output_only = false
                   @problem.date_added = Time.new
                   if @problem.save
                     flash[:notice] = 'Problem was successfully created.'
                     redirect_to action: :index
                   if @problem.update_attributes(params[:problem])
                     flash[:notice] = 'Problem was successfully updated.'
                     unless params[:file] == nil or params[:file] == ''
                       flash[:notice] = 'Problem was successfully updated and a new PDF file is uploaded.'
                       out_dirname = "#{Problem.download_file_basedir}/#{@problem.id}"
                       if not FileTest.exists? out_dirname
                         Dir.mkdir out_dirname
                       end
                       out_filename = "#{out_dirname}/#{@problem.name}.pdf"
                       if FileTest.exists? out_filename
                         File.delete out_filename
                       end
                       File.open(out_filename,"wb") do |file|
                         file.write(params[:file].read)
                       end
                       @problem.description_filename = "#{@problem.name}.pdf"
                       @problem.save
                     end
                     redirect_to :action => 'show', :id => @problem
                   else
                     render :action => 'edit'
                   end
                 end
                 def destroy
                   p = Problem.find(params[:id]).destroy
                   redirect_to action: :index
                 end
                 def toggle
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(available: !(@problem.available) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def toggle_test
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(test_allowed: !(@problem.test_allowed?) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def turn_all_off
-            -     Problem.find(:all,
+            +     Problem.available.all.each do |problem|
-            -                  :conditions => "available = 1").each do |problem|
                     problem.available = false
                     problem.save
                   end
                   redirect_to action: :index
                 end
                 def turn_all_on
-            -     Problem.find(:all,
+            +     Problem.where.not(available: true).each do |problem|
-            -                  :conditions => "available = 0").each do |problem|
                     problem.available = true
                     problem.save
                   end
                   redirect_to action: :index
                 end
                 def stat
                   @problem = Problem.find(params[:id])
                   unless @problem.available or session[:admin]
                     redirect_to :controller => 'main', :action => 'list'
                     return
                   end
                   @submissions = Submission.includes(:user).where(problem_id: params[:id]).order(:user_id,:id)
                   #stat summary
                   range =65
                   @histogram = { data: Array.new(range,0), summary: {} }
                   user = Hash.new(0)
                   @submissions.find_each do |sub|
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     @histogram[:data][d.to_i] += 1 if d < range
                     user[sub.user_id] = [user[sub.user_id], ((sub.try(:points) || 0) >= @problem.full_score) ? 1 : 0].max
                   end
                   @histogram[:summary][:max] = [@histogram[:data].max,1].max
                   @summary = { attempt: user.count, solve: 0 }
                   user.each_value { |v| @summary[:solve] += 1 if v == 1 }
                 end
                 def manage
-            -     @problems = Problem.find(:all, :order => 'date_added DESC')
+            +     @problems = Problem.order(date_added: :desc)
                 end
                 def do_manage
                   if params.has_key? 'change_date_added'
                     change_date_added
                   elsif params.has_key? 'add_to_contest'
                     add_to_contest
                   elsif params.has_key? 'enable_problem'
                     set_available(true)
                   elsif params.has_key? 'disable_problem'
                     set_available(false)
                   end
                   redirect_to :action => 'manage'
                 end
                 def import
                   @allow_test_pair_import = allow_test_pair_import?
                 end
                 def do_import
                   old_problem = Problem.find_by_name(params[:name])
                   if !allow_test_pair_import? and params.has_key? :import_to_db
                     params.delete :import_to_db
                   end
                   @problem, import_log = Problem.create_from_import_form_params(params,
                                                                                 old_problem)
                   if !@problem.errors.empty?
                     render :action => 'import' and return
                   end
                   if old_problem!=nil
                     flash[:notice] = "The test data has been replaced for problem #{@problem.name}"
                   end
                   @log = import_log
                 end
                 def remove_contest
                   problem = Problem.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if problem!=nil and contest!=nil
                     problem.contests.delete(contest)
                   end
                   redirect_to :action => 'manage'
                 end
                 ##################################
                 protected

app/controllers/report_controller.rb ¶ +5 -9

               require 'csv'
               class ReportController < ApplicationController
                 before_filter :authenticate
                 before_filter :admin_authorization, only: [:login_stat,:submission_stat, :stuck, :cheat_report, :cheat_scruntinize, :show_max_score]
                 before_filter(only: [:problem_hof]) { |c|
                   return false unless authenticate
-            -     if GraderConfiguration["right.user_view_submission"]
+            +     admin_authorization unless GraderConfiguration["right.user_view_submission"]
-            -       return true;
-            -     end
-            -     admin_authorization
                 }
                 def max_score
                 end
                 def current_score
-            -     @problems = Problem.find_available_problems
+            +     @problems = Problem.available_problems
                   @users = User.includes(:contests).includes(:contest_stat).where(enabled: true)
                   @scorearray = calculate_max_score(@problems, @users,0,0,true)
                   #rencer accordingly
                   if params[:button] == 'download' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'max_score.csv'
                   else
                     #render template: 'user_admin/user_stat'
                     render 'current_score'
                   end
                 end
                 def show_max_score
                   #process parameters
                   #problems
                   @problems = []
                   params[:problem_id].each do |id|
                     next unless id.strip != ""
                     pid = Problem.find_by_id(id.to_i)
                     @problems << pid if pid
                   end
                   #users
                   @users = if params[:user] == "all" then
-            -                User.find(:all, :include => [:contests, :contest_stat])
+            +                User.includes(:contests).includes(:contest_stat)
                            else
                              User.includes(:contests).includes(:contest_stat).where(enabled: true)
                            end
                   #set up range from param
                   since_id = params.fetch(:from_id, 0).to_i
                   until_id = params.fetch(:to_id, 0).to_i
                   #calculate the routine
                   @scorearray = calculate_max_score(@problems, @users,since_id,until_id)
                   #rencer accordingly
                   if params[:button] == 'download' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'max_score.csv'
                   else
                     #render template: 'user_admin/user_stat'
                     render 'max_score'
                   end
                 end
                 def score
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else
-            -       @problems = Problem.find_available_problems
+            +       @problems = Problem.available_problems
                   end
-            -     @users = User.includes(:contests, :contest_stat).where(enabled: true) #find(:all, :include => [:contests, :contest_stat]).where(enabled: true)
+            +     @users = User.includes(:contests, :contest_stat).where(enabled: true)
                   @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) and p and p.full_score
                         ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
                       else
                         ustat << [0,false]
                       end
                     end
                     @scorearray << ustat
                   end
                   if params[:commit] == 'download csv' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'last_score.csv'
                   else
                     render template: 'user_admin/user_stat'
                   end
                 end
                 def login_stat
                   @logins = Array.new
                   date_and_time = '%Y-%m-%d %H:%M'
                   begin
                     md = params[:since_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
                     @since_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
                   rescue
                     @since_time = DateTime.new(1000,1,1)
                   end
                   begin
                     md = params[:until_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
                     @until_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
                   rescue
                     @until_time = DateTime.new(3000,1,1)
                   end
                   User.all.each do |user|
                     @logins << { id: user.id,
                                  login: user.login,
                                  full_name: user.full_name,
                                  count: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .count(:id),
                                  min: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",

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

               class SiteController < ApplicationController
                 before_filter :site_admin_authorization, :except => 'login'
                 def login
                   # Site administrator login
-            -     @countries = Country.find(:all, :include => :sites)
+            +     @countries = Country.includes(:sites).all
                   @country_select = @countries.collect { |c| [c.name, c.id] }
                   @country_select_with_all = [['Any',0]]
                   @countries.each do |country|
                     @country_select_with_all << [country.name, country.id]
                   end
                   @site_select = []
                   @countries.each do |country|
                     country.sites.each do |site|
                       @site_select << ["#{site.name}, #{country.name}", site.id]
                     end
                   end
                   @default_site = Site.first if !GraderConfiguration['contest.multisites']
                   render :action => 'login', :layout => 'empty'
                 end
                 def index
                   if @site.started
                     render :action => 'started', :layout => 'empty'
                   else
                     render :action => 'prompt', :layout => 'empty'
                   end
                 end
                 def start
                   @site.started = true
                   @site.start_time = Time.new.gmtime
                   @site.save
                   redirect_to :action => 'index'
                 end
                 def logout
                   reset_session
                   redirect_to :controller => 'main', :action => 'login'
                 end
                 protected
                 def site_admin_authorization
                   if session[:site_id]==nil
                     redirect_to :controller => 'site', :action => 'login' and return
                   end
                   begin
                     @site = Site.find(session[:site_id], :include => :country)
                   rescue ActiveRecord::RecordNotFound
                     @site = nil

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

               class SitesController < ApplicationController
                 before_filter :admin_authorization
                 # GET /sites
                 # GET /sites.xml
                 def index
-            -     @sites = Site.find(:all, :order => 'country_id')
+            +     @sites = Site.order(:country_id)
                   respond_to do |format|
                     format.html # index.html.erb
                     format.xml  { render :xml => @sites }
                   end
                 end
                 # GET /sites/1
                 # GET /sites/1.xml
                 def show
                   @site = Site.find(params[:id])
                   respond_to do |format|
                     format.html # show.html.erb
                     format.xml  { render :xml => @site }
                   end
                 end
                 # GET /sites/new
                 # GET /sites/new.xml
                 def new
                   @site = Site.new
                   respond_to do |format|
                     format.html # new.html.erb
                     format.xml  { render :xml => @site }
                   end
                 end
                 # GET /sites/1/edit
                 def edit
                   @site = Site.find(params[:id])
                 end
                 # POST /sites
                 # POST /sites.xml
                 def create
                   @site = Site.new(params[:site])
                   @site.clear_start_time_if_not_started
                   respond_to do |format|
                     if @site.save
                       flash[:notice] = 'Site was successfully created.'
                       format.html { redirect_to(@site) }
                       format.xml  { render :xml => @site, :status => :created, :location => @site }
                     else
                       format.html { render :action => "new" }
                       format.xml  { render :xml => @site.errors, :status => :unprocessable_entity }

app/controllers/user_admin_controller.rb ¶ +7 -7

               require 'csv'
               class UserAdminController < ApplicationController
                 include MailHelperMethods
                 before_filter :admin_authorization
                 # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
                 verify :method => :post, :only => [
                                                     :create, :create_from_list,
                                                     :update,
                                                     :manage_contest,
                                                     :bulk_mail
                                                   ],
                        :redirect_to => { :action => :list }
                 def index
                   @user_count = User.count
                   if params[:page] == 'all'
                     @users = User.all
                     @paginated = false
                   else
                     @users = User.paginate :page => params[:page]
                     @paginated = true
                   end
                   @hidden_columns = ['hashed_password', 'salt', 'created_at', 'updated_at']
                   @contests = Contest.enabled
                 end
                 def active
-            -     sessions = ActiveRecord::SessionStore::Session.find(:all, :conditions => ["updated_at >= ?", 60.minutes.ago])
+            +     sessions = ActiveRecord::SessionStore::Session.where("updated_at >= ?", 60.minutes.ago)
                   @users = []
                   sessions.each do |session|
                     if session.data[:user_id]
                       @users << User.find(session.data[:user_id])
                     end
                   end
                 end
                 def show
                   @user = User.find(params[:id])
                 end
                 def new
                   @user = User.new
                 end
                 def create
                   @user = User.new(params[:user])
                   @user.activated = true
                   if @user.save
                     flash[:notice] = 'User was successfully created.'
                     redirect_to :action => 'index'
                   else
                     render :action => 'new'
                   end
                 end
                 def clear_last_ip
                   @user = User.find(params[:id])
                   @user.last_ip = nil
                   @user.save
                   redirect_to action: 'index', page: params[:page]
                 end
                 def create_from_list
                   lines = params[:user_list]
                   note = []
                   lines.split("\n").each do |line|
                     items = line.chomp.split(',')
                     if items.length>=2
                       login = items[0]
                       full_name = items[1]
                       added_random_password = false
                       if items.length>=3
                         password = items[2].chomp(" ")
                         user.full_name = full_name
                         user.password = password
                       else
                         user = User.new({:login => login,
                                           :full_name => full_name,
                                           :password => password,
                                           :password_confirmation => password,
                                           :alias => user_alias})
                       end
                       user.activated = true
                       user.save
                       if added_random_password
                         note << "'#{login}' (+)"
                       else
                         note << login
                       end
                     end
                   end
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     ' were successfully created.  ' +
                     '( (+) - created with random passwords.)'
                   redirect_to :action => 'index'
                 end
                 def edit
                   @user = User.find(params[:id])
                 end
                 def update
                   @user = User.find(params[:id])
                   if @user.update_attributes(user_params)
                     flash[:notice] = 'User was successfully updated.'
                     redirect_to :action => 'show', :id => @user
                   else
                     render :action => 'edit'
                   end
                 end
                 def destroy
                   User.find(params[:id]).destroy
                   redirect_to :action => 'index'
                 end
                 def user_stat
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else
-            -       @problems = Problem.find_available_problems
+            +       @problems = Problem.available_problems
                   end
-            -     @users = User.includes(:contests, :contest_stat).where(enabled: true) #find(:all, :include => [:contests, :contest_stat]).where(enabled: true)
+            +     @users = User.includes(:contests, :contest_stat).where(enabled: true)
                   @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) and p and p.full_score
                         ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
                       else
                         ustat << [0,false]
                       end
                     end
                     @scorearray << ustat
                   end
                   if params[:commit] == 'download csv' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'last_score.csv'
                   else
                     render template: 'user_admin/user_stat'
                   end
                 end
                 def user_stat_max
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else
-            -       @problems = Problem.find_available_problems
+            +       @problems = Problem.available_problems
                   end
-            -     @users = User.find(:all, :include => [:contests, :contest_stat])
+            +     @users = User.includes(:contests).includes(:contest_stat).all
                   @scorearray = Array.new
                   #set up range from param
                   since_id = params.fetch(:since_id, 0).to_i
                   until_id = params.fetch(:until_id, 0).to_i
                   @users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     @problems.each do |p|
                       max_points = 0
                       Submission.find_in_range_by_user_and_problem(u.id,p.id,since_id,until_id).each do |sub|
                         max_points = sub.points if sub and sub.points and (sub.points > max_points)
                       end
                       ustat << [(max_points.to_f*100/p.full_score).round, (max_points>=p.full_score)]
                     end
                     @scorearray << ustat
                   end
                   if params[:commit] == 'download csv' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'max_score.csv'
                   else
                     render template: 'user_admin/user_stat'
                   end
                 end
                 def import
                   if params[:file]==''
                     flash[:notice] = 'Error importing no file'
                     redirect_to :action => 'index' and return
                   end
                   import_from_file(params[:file])
                 end
                 def random_all_passwords
-            -     users = User.find(:all)
+            +     users = User.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 contests
                   @contest, @users = find_contest_and_user_from_contest_id(params[:id])
                   @contests = Contest.enabled
                 end
                 def assign_from_list
                   contest_id = params[:users_contest_id]
                   org_contest, users = find_contest_and_user_from_contest_id(contest_id)
                   contest = Contest.find(params[:new_contest][:id])
                   if !contest
                     flash[:notice] = 'Error: no contest'
                     redirect_to :action => 'contests', :id =>contest_id
                   end
                   note = []
                   users.each do |u|
                     u.contests = [contest]
                     note << u.login
                   end
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     " were successfully reassigned to #{contest.title}."
                   redirect_to :action => 'contests', :id =>contest.id
                 end
                 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 => 'index'
                 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 = []
                   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
                       if params[:reset_timer]
                         user.contest_stat.forced_logout = true
                         user.contest_stat.reset_timer_and_save
                       end
                       if params[:notification_emails]
                         send_contest_update_notification_email(user, contest)
                       end
                       note << user.login
                       users << user
                     end
                   end
                   if params[:reset_timer]
                     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? }
+            +     @admins = User.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
                 # mass mailing
                 def mass_mailing
                 end
                 def bulk_mail
                   lines = params[:login_list]
                   if !lines or lines.blank?
                     flash[:notice] = 'You entered an empty list.'
                     redirect_to :action => 'mass_mailing' and return
                   end
                   mail_subject = params[:subject]
                   if !mail_subject or mail_subject.blank?
                     flash[:notice] = 'You entered an empty mail subject.'
                     redirect_to :action => 'mass_mailing' and return
                   end

app/models/announcement.rb ¶ +5 -11

               class Announcement < ActiveRecord::Base
-            -   def self.find_published(contest_started=false)
+            +   def self.published(contest_started=false)
                   if contest_started
-            -       Announcement.find(:all,
+            +       where(published: true).where(frontpage: false).order(created_at: :desc)
-            -                         :conditions => "(published = 1) AND (frontpage = 0)",
-            -                         :order => "created_at DESC")
                   else
-            -       Announcement.find(:all,
+            +       where(published: true).where(frontpage: false).where(contest_only: false).order(created_at: :desc)
-            -                         :conditions => "(published = 1) AND (frontpage = 0) AND (contest_only = 0)",
-            -                         :order => "created_at DESC")
                   end
                 end
-            -   def self.find_for_frontpage
+            +   def self.frontpage
-            -     Announcement.find(:all,
+            +     where(published: 1).where(frontpage: 1).order(created_at: :desc)
-            -                       :conditions => "(published = 1) AND (frontpage = 1)",
-            -                       :order => "created_at DESC")
                 end
               end

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

                 def self.time_limit_mode?
                   mode = get(SYSTEM_MODE_CONF_KEY)
                   return ((mode == 'contest') or (mode == 'indv-contest'))
                 end
                 def self.analysis_mode?
                   return get(SYSTEM_MODE_CONF_KEY) == 'analysis'
                 end
                 def self.contest_time_limit
                   contest_time_str = GraderConfiguration[CONTEST_TIME_LIMIT_KEY]
                   if not defined? GraderConfiguration.contest_time_str
                     GraderConfiguration.contest_time_str = nil
                   end
                   if GraderConfiguration.contest_time_str != contest_time_str
                     GraderConfiguration.contest_time_str = contest_time_str
                     if tmatch = /(\d+):(\d+)/.match(contest_time_str)
                       h = tmatch[1].to_i
                       m = tmatch[2].to_i
                       GraderConfiguration.contest_time = h.hour + m.minute
                     else
                       GraderConfiguration.contest_time = nil
                     end
                   end
                   return GraderConfiguration.contest_time
                 end
                 protected
                 def self.convert_type(val,type)
                   case type
                   when 'string'
                     return val
                   when 'integer'
                     return val.to_i
                   when 'boolean'
                     return (val=='true')
                   end
                 end
                 def self.read_config
                   GraderConfiguration.config_cache = {}
-            -     GraderConfiguration.find(:all).each do |conf|
+            +     GraderConfiguration.all.each do |conf|
                     key = conf.key
                     val = conf.value
                     GraderConfiguration.config_cache[key] = GraderConfiguration.convert_type(val,conf.value_type)
                   end
                 end
                 def self.read_one_key(key)
                   conf = GraderConfiguration.find_by_key(key)
                   if conf
                     return GraderConfiguration.convert_type(conf.value,conf.value_type)
                   else
                     return nil
                   end
                 end
                 def self.read_grading_info
                   f = File.open(TASK_GRADING_INFO_FILENAME)
                   GraderConfiguration.task_grading_info_cache = YAML.load(f)
                   f.close
                 end
               end

app/models/grader_process.rb ¶ +4 -13

               class GraderProcess < ActiveRecord::Base
                 def self.find_by_host_and_pid(host,pid)
-            -     return GraderProcess.find(:first,
+            +     return GraderProcess.where(host:host).where(pid: pid).first
-            -                               :conditions => {
-            -                                 :host => host,
-            -                                 :pid => pid
-            -                               })
                 end
                 def self.register(host,pid,mode)
                   grader = GraderProcess.find_by_host_and_pid(host,pid)
                   if grader
                     grader.mode = mode
                     grader.active = nil
                     grader.task_id = nil
                     grader.task_type = nil
                     grader.terminated = false
                     grader.save
                   else
                     grader = GraderProcess.create(:host => host,
                                                   :pid => pid,
                                                   :mode => mode,
                                                   :terminated => false)
                   end
                   grader
                 end
                 def self.find_running_graders
-            -     GraderProcess.find(:all,
+            +     where(terminated: false)
-            -                        :conditions => {:terminated => 0})
                 end
                 def self.find_terminated_graders
-            -     GraderProcess.find(:all,
+            +     where(terminated: true)
-            -                        :conditions => "`terminated`")
                 end
                 def self.find_stalled_process
-            -     GraderProcess.find(:all,
+            +     where(terminated: false).where(active: true).where("updated_at < ?",Time.now.gmtime - GraderProcess.stalled_time)
-            -                        :conditions => ["(`terminated` = 0) AND active AND " +
-            -                                        "(updated_at < ?)",
-            -                                        Time.now.gmtime - GraderProcess.stalled_time])
                 end
                 def report_active(task=nil)
                   self.active = true
                   if task!=nil
                     self.task_id = task.id
                     self.task_type = task.class.to_s
                   else
                     self.task_id = nil
                     self.task_type = nil
                   end
                   self.save
                 end
                 def report_inactive(task=nil)
                   self.active = false
                   if task!=nil
                     self.task_id = task.id
                     self.task_type = task.class.to_s
                   else
                     self.task_id = nil
                     self.task_type = nil
                   end
                   self.save
                 end
                 def terminate
                   self.terminated = true
                   self.save
                 end
                 protected
                 def self.stalled_time()
                   return 1.minute
                 end
               end

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

               class Language < ActiveRecord::Base
                 @@languages_by_ext = {}
                 def self.cache_ext_hash
                   @@languages_by_ext = {}
-            -     Language.find(:all).each do |language|
+            +     Language.all.each do |language|
                     language.common_ext.split(',').each do |ext|
                       @@languages_by_ext[ext] = language
                     end
                   end
                 end
                 def self.find_by_extension(ext)
                   if @@languages_by_ext.length == 0
                     Language.cache_ext_hash
                   end
                   if @@languages_by_ext.has_key? ext
                     return @@languages_by_ext[ext]
                   else
                     return nil
                   end
                 end
               end

app/models/message.rb ¶ +2 -4

               class Message < ActiveRecord::Base
                 belongs_to :sender, :class_name => "User"
                 belongs_to :receiver, :class_name => "User"
                 belongs_to :replying_message, :class_name => "Message"
                 # commented manually do it
                 #
                 #has_many :replied_messages, {
                 #  :class_name => "Message",
                 #  :foreign_key => "replying_message_id"
                 #}
                 #
                 attr_accessor :replied_messages
                 def self.find_all_sent_by_user(user)
                   messages = user.messages
                   replied_messages = user.replied_messages
                   Message.build_replying_message_hierarchy messages, replied_messages
                   return messages
                 end
                 def self.find_all_system_unreplied_messages
-            -     self.find(:all,
+            +     where('ISNULL(receiver_id) ' +
-            -               :conditions => 'ISNULL(receiver_id) ' +
+            +           'AND (ISNULL(replied) OR replied=0)')
-            -                              'AND (ISNULL(replied) OR replied=0)',
-            -               :order => 'created_at')
                 end
                 def self.build_replying_message_hierarchy(*args)
                   # manually build replies hierarchy (to improve efficiency)
                   all_messages = {}
                   args.each do |collection|
                     collection.each do |m|
                       all_messages[m.id] = m
                       m.replied_messages = []
                     end
                   end
                   all_messages.each_value do |m|
                     rep_id = m.replying_message_id
                     if all_messages[rep_id]!=nil
                       all_messages[rep_id].add_replied_message(m)
                     end
                   end
                 end
                 def add_replied_message(m)
                   if @replied_messages==nil
                     @replied_messages = [m]
                   else
                     @replied_messages << m
                   end
                   @replied_messages
                 end
               end

app/models/problem.rb ¶ +4 -3

               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 => /\A\w+\z/
                 validates_presence_of :full_name
-            -   scope :available, :conditions => {:available => true}
+            +   scope :available, -> { where(available: true) }
                 DEFAULT_TIME_LIMIT = 1
                 DEFAULT_MEMORY_LIMIT = 32
-            -   def self.find_available_problems
+            +   def self.available_problems
-            -     Problem.available.all(:order => "date_added DESC, name ASC")
+            +     available.order(date_added: :desc).order(:name)
+            +     #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

app/models/submission.rb ¶ +4 -17

               class Submission < ActiveRecord::Base
                 belongs_to :language
                 belongs_to :problem
                 belongs_to :user
                 before_validation :assign_problem
                 before_validation :assign_language
                 validates_presence_of :source
                 validates_length_of :source, :maximum => 100_000, :allow_blank => true, :message => 'too long'
                 validates_length_of :source, :minimum => 1, :allow_blank => true, :message => 'too short'
                 validate :must_have_valid_problem
                 validate :must_specify_language
                 before_save :assign_latest_number_if_new_recond
                 def self.find_last_by_user_and_problem(user_id, problem_id)
-            -     last_sub = find(:first,
+            +     where("user_id = ? AND problem_id = ?",user_id,problem_id).last
-            -                     :conditions => {:user_id => user_id,
-            -                       :problem_id => problem_id},
-            -                     :order => 'number DESC')
-            -     return last_sub
                 end
                 def self.find_all_last_by_problem(problem_id)
                   # need to put in SQL command, maybe there's a better way
                   Submission.includes(:user).find_by_sql("SELECT * FROM submissions " +
               			   "WHERE id = " +
               			   "(SELECT MAX(id) FROM submissions AS subs " +
               			   "WHERE subs.user_id = submissions.user_id AND " +
                                          "problem_id = " + problem_id.to_s + " " +
               			   "GROUP BY user_id) " +
                                          "ORDER BY user_id")
                 end
                 def self.find_in_range_by_user_and_problem(user_id, problem_id,since_id,until_id)
                   records = Submission.where(problem_id: problem_id,user_id: user_id)
                   records = records.where('id >= ?',since_id) if since_id > 0
                   records = records.where('id <= ?',until_id) if until_id > 0
                   records.all
                 end
                 def self.find_last_for_all_available_problems(user_id)
                   submissions = Array.new
-            -     problems = Problem.find_available_problems
+            +     problems = Problem.available_problems
                   problems.each do |problem|
                     sub = Submission.find_last_by_user_and_problem(user_id, problem.id)
                     submissions << sub if sub!=nil
                   end
                   submissions
                 end
                 def self.find_by_user_problem_number(user_id, problem_id, number)
-            -     Submission.find(:first,
+            +     where("user_id = ? AND problem_id = ? AND number = ?",user_id,problem_id,number).first
-            -                     :conditions => {
-            -                       :user_id => user_id,
-            -                       :problem_id => problem_id,
-            -                       :number => number
-            -                     })
                 end
                 def self.find_all_by_user_problem(user_id, problem_id)
-            -     Submission.find(:all,
+            +     where("user_id = ? AND problem_id = ?",user_id,problem_id)
-            -                     :conditions => {
-            -                       :user_id => user_id,
-            -                       :problem_id => problem_id,
-            -                     })
                 end
                 def download_filename
                   if self.problem.output_only
                     return self.source_filename
                   else
                     timestamp = self.submitted_at.localtime.strftime("%H%M%S")
                     return "#{self.problem.name}-#{timestamp}.#{self.language.ext}"
                   end
                 end
                 protected
                 def self.find_option_in_source(option, source)
                   if source==nil
                     return nil
                   end
                   i = 0
                   source.each_line do |s|
                     if s =~ option
               	words = s.split
               	return words[1]
                     end
                     i = i + 1
                     if i==10
               	return nil
                     end
                   end
                   return nil
                 end
                 def self.find_language_in_source(source, source_filename="")
                   langopt = find_option_in_source(/^LANG:/,source)
                   if langopt
                     return (Language.find_by_name(langopt) ||
                             Language.find_by_pretty_name(langopt))
                   else
                     if source_filename
                       return Language.find_by_extension(source_filename.split('.').last)
                     else
                       return nil
                     end
                   end
                 end
                 def self.find_problem_in_source(source, source_filename="")
                   prob_opt = find_option_in_source(/^TASK:/,source)
                   if problem = Problem.find_by_name(prob_opt)

app/models/task.rb ¶ +1 -4

                 belongs_to :submission
                 STATUS_GRADING = 0
                 STATUS_INQUEUE = 1
                 STATUS_COMPLETE = 2
                 def status_inqueue
                   self.status = Task::STATUS_INQUEUE
                 end
                 def status_inqueue!
                   status_inqueue
                   self.save
                 end
                 def status_grading
                   self.status = Task::STATUS_GRADING
                 end
                 def status_grading!
                   status_grading
                   self.save
                 end
                 def status_complete
                   self.status = Task::STATUS_COMPLETE
                 end
                 def status_complete!
                   status_complete
                   self.save
                 end
                 def status_str
                   case self.status
                   when Task::STATUS_INQUEUE
                     "inqueue"
                   when Task::STATUS_GRADING
                     "grading"
                   when Task::STATUS_COMPLETE
                     "complete"
                   end
                 end
                 def self.get_inqueue_and_change_status(status)
                   task = nil
                   begin
                     Task.transaction do
-            -         task = Task.find(:first,
+            +         task = Task.where(status: Task::STATUS_INQUEUE).where(lock: true).first
-            -                          :order => "created_at",
-            -                          :conditions => {:status=> Task::STATUS_INQUEUE},
-            -                          :lock => true)
                       if task!=nil
                         task.status = status
                         task.save!
                       end
                     end
                   rescue
                     task = nil
                   end
                   task
                 end
               end

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

               #
               # 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"
                 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,
+            +     test_request = TestRequest.where(status: Task::STATUS_INQUEUE).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

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

                 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)
+            +     users = User.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)
+            +     users = User.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
                   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
+            +       return Problem.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

app/views/report/_score_table.html.haml ¶ +1 -1

               %table.table.sortable.table-striped.table-bordered.table-condensed
                 %thead
                   %tr
                     %th Login
                     %th Name
                     / %th Activated?
                     / %th Logged_in
                     / %th Contest(s)
                     %th Remark
                     - @problems.each do |p|
                       %th.text-right= p.name.gsub('_',' ')
                     %th.text-right Total
                     %th.text-right Passed
                 %tbody
                   - @scorearray.each do |sc|
                     %tr
                       - total,num_passed = 0,0
                       - sc.each_index do |i|
                         - if i == 0
-            -             %td= link_to sc[i].login, controller: 'users', action: 'profile', id: sc[i]
+            +             %td= link_to sc[i].login, stat_user_path(sc[i])
                           %td= sc[i].full_name
                           / %td= sc[i].activated
                           / %td= sc[i].try(:contest_stat).try(:started_at) ? 'yes' : 'no'
                           / %td= sc[i].contests.collect {|c| c.name}.join(', ')
                           %td= sc[i].remark
                         - else
                           %td.text-right= sc[i][0]
                           - total += sc[i][0]
                           - num_passed += 1 if sc[i][1]
                       %td.text-right= total
                       %td.text-right= num_passed
               :javascript
                 $.bootstrapSortable(true,'reversed')

test/concurrent/task_test_setup.rb ¶ +1 -1

               ENV["RAILS_ENV"] = "test"
               require File.expand_path(File.dirname(__FILE__) + "/../../config/environment")
               def clear_all_tasks
-            -   Task.find(:all).each do |task|
+            +   Task.all.each do |task|
                   task.destroy
                 end
               end
               clear_all_tasks
               (1..1000).each do |i|
                 Task.create(:id => i,
                             :submission_id => i,
                             :status => Task::STATUS_INQUEUE)
               end

test/concurrent/task_test_teardown.rb ¶ +2 -3

               ENV["RAILS_ENV"] = "test"
               require File.expand_path(File.dirname(__FILE__) + "/../../config/environment")
               def clear_all_tasks
-            -   Task.find(:all).each do |task|
+            +   Task.all.each do |task|
                   task.destroy
                 end
               end
-            - puts Task.find(:all,
+            + puts Task.where(status: Task::STATUS_COMPLETE).length
-            -                :conditions => {:status => Task::STATUS_COMPLETE}).length
               clear_all_tasks

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

r619:35d86016ce86 - Tue, 06 Dec 2016 17:01:12 - 26 files changed: 108 inserted, 147 deleted

Sign in to your account

Commit r619:35d86016ce86 public

Author

r619:35d86016ce86 - Tue, 06 Dec 2016 17:01:12 - 26 files changed: 108 inserted, 147 deleted

Commit `r619:35d86016ce86` public