cafe-grader-web Commit - r745:75264caa616f

cafe-grader-web

Commit `r745:75264caa616f` public

parent | child

Description:

change depricated before_filter to before_action

Commit status:

[Not Reviewed]

References:

algo

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r745:75264caa616f - Wed, 03 Jul 2019 10:25:07 - 20 files changed: 38 inserted, 31 deleted

Gemfile ¶ +1

               source 'https://rubygems.org'
               #rails
               gem 'rails', '~>5.0'
               gem 'activerecord-session_store'
               # Bundle edge Rails instead:
               # gem 'rails', :git => 'git://github.com/rails/rails.git'
               #---------------- database ---------------------
               #the database
               gem 'mysql2'
               #for testing
               gem 'sqlite3'
+            + gem 'rails-controller-testing'
               #for dumping database into yaml
               gem 'yaml_db'
               # Gems used only for assets and not required
               # in production environments by default.
               gem 'sass-rails'
               gem 'coffee-rails'
                 # See https://github.com/sstephenson/execjs#readme for more supported runtimes
                 # gem 'therubyracer', :platforms => :ruby
               gem 'uglifier'
               gem 'haml'
               gem 'haml-rails'
               # 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

Gemfile.lock ¶ +5

                     minitest (>= 5.0)
                     ruby-progressbar
                   momentjs-rails (2.20.1)
                     railties (>= 3.1)
                   multi_json (1.13.1)
                   mysql2 (0.5.2)
                   nio4r (2.3.1)
                   nokogiri (1.10.3)
                     mini_portile2 (~> 2.4.0)
                   rack (2.0.7)
                   rack-test (0.6.3)
                     rack (>= 1.0)
                   rails (5.0.7.2)
                     actioncable (= 5.0.7.2)
                     actionmailer (= 5.0.7.2)
                     actionpack (= 5.0.7.2)
                     actionview (= 5.0.7.2)
                     activejob (= 5.0.7.2)
                     activemodel (= 5.0.7.2)
                     activerecord (= 5.0.7.2)
                     activesupport (= 5.0.7.2)
                     bundler (>= 1.3.0)
                     railties (= 5.0.7.2)
                     sprockets-rails (>= 2.0.0)
+            +     rails-controller-testing (1.0.4)
+            +       actionpack (>= 5.0.1.x)
+            +       actionview (>= 5.0.1.x)
+            +       activesupport (>= 5.0.1.x)
                   rails-dom-testing (2.0.3)
                     activesupport (>= 4.2.0)
                     nokogiri (>= 1.6)
                   rails-html-sanitizer (1.0.4)
                     loofah (~> 2.2, >= 2.2.2)
                   rails_bootstrap_sortable (2.0.6)
                     momentjs-rails (>= 2.8.3)
                   railties (5.0.7.2)
                     actionpack (= 5.0.7.2)
                     activesupport (= 5.0.7.2)
                     method_source
                     rake (>= 0.8.7)
                     thor (>= 0.18.1, < 2.0)
                   rake (12.3.2)
                   rb-fsevent (0.10.3)
                   rb-inotify (0.10.0)
                     ffi (~> 1.0)
                   rdiscount (2.2.0.1)
                   rouge (3.3.0)
                   ruby-progressbar (1.10.0)
                   ruby_parser (3.13.1)
                     sexp_processor (~> 4.9)
                   sass (3.7.4)
                     sass-listen (~> 4.0.0)
                 autoprefixer-rails
                 best_in_place (~> 3.0.1)
                 bootstrap-datepicker-rails
                 bootstrap-sass (~> 3.4.1)
                 bootstrap-switch-rails
                 bootstrap-toggle-rails
                 bootstrap3-datetimepicker-rails
                 coffee-rails
                 dynamic_form
                 fuzzy-string-match
                 haml
                 haml-rails
                 in_place_editing
                 jquery-countdown-rails
                 jquery-datatables-rails
                 jquery-rails
                 jquery-tablesorter
                 jquery-timepicker-addon-rails
                 jquery-ui-rails
                 mail
                 minitest-reporters
                 momentjs-rails
                 mysql2
                 rails (~> 5.0)
+            +   rails-controller-testing
                 rails_bootstrap_sortable
                 rdiscount
                 rouge
                 sass-rails
                 sassc-rails (>= 2.1.0)
                 select2-rails
                 sqlite3
                 uglifier
                 verification!
                 will_paginate (~> 3.0.7)
                 yaml_db
               BUNDLED WITH
 .17.2

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

               class AnnouncementsController < ApplicationController
-            -   before_filter :admin_authorization
+            +   before_action :admin_authorization
                 in_place_edit_for :announcement, :published
                 # GET /announcements
                 # GET /announcements.xml
                 def index
                   @announcements = Announcement.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

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

               class ApplicationController < ActionController::Base
                 protect_from_forgery
-            -   before_filter :current_user
+            +   before_action :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.includes(:roles).find(session[:user_id])
                   unless user.admin?
                     unauthorized_redirect
                     return false
                   end
                   return true

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

               class ConfigurationsController < ApplicationController
-            -   before_filter :authenticate
+            +   before_action :authenticate
-            -   before_filter { |controller| controller.authorization_by_roles(['admin'])}
+            +   before_action { |controller| controller.authorization_by_roles(['admin'])}
                 def index
                   @configurations = GraderConfiguration.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

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

               class ContestManagementController < ApplicationController
-            -   before_filter :admin_authorization
+            +   before_action :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.all
                   @start_times = {}
                   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

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

               class ContestsController < ApplicationController
-            -   before_filter :admin_authorization
+            +   before_action :admin_authorization
                 in_place_edit_for :contest, :title
                 in_place_edit_for :contest, :enabled
                 # GET /contests
                 # GET /contests.xml
                 def index
                   @contests = Contest.all
                   respond_to do |format|
                     format.html # index.html.erb
                     format.xml  { render :xml => @contests }
                   end
                 end
                 # GET /contests/1
                 # GET /contests/1.xml
                 def show
                   @contest = Contest.find(params[:id])
                   respond_to do |format|
                     format.html # show.html.erb
                     format.xml  { render :xml => @contest }
                   end

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

               class GradersController < ApplicationController
-            -   before_filter :admin_authorization
+            +   before_action :admin_authorization
                 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.last
                   @last_test_request = TestRequest.last
                   @submission = Submission.order("id desc").limit(20)
                   @backlog_submission = Submission.where('graded_at is null')
                 end

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

               class HeartbeatController < ApplicationController
-            -   before_filter :admin_authorization, :only => ['index']
+            +   before_action :admin_authorization, :only => ['index']
                 def edit
                   #@user = User.find_by_login(params[:id])
                   #unless @user
                   #  render text: "LOGIN_NOT_FOUND"
                   #  return
                   #end
                   #hb = HeartBeat.where(user_id: @user.id, ip_address: request.remote_ip).first
                   #puts "status = #{params[:status]}"
                   #if hb
                   #  if params[:status]
                   #    hb.status = params[:status]
                   #    hb.save
                   #  end
                   #  hb.touch
                   #else
                   #  HeartBeat.creae(user_id: @user.id, ip_address: request.remote_ip)
                   #end
                   #HeartBeat.create(user_id: @user.id, ip_address: request.remote_ip, status: params[:status])
                   res = GraderConfiguration['right.heartbeat_response']
                   res.strip! if res
                   full = GraderConfiguration['right.heartbeat_response_full']

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

               class MainController < ApplicationController
-            -   before_filter :authenticate, :except => [:index, :login]
+            +   before_action :authenticate, :except => [:index, :login]
-            -   before_filter :check_viewability, :except => [:index, :login]
+            +   before_action :check_viewability, :except => [:index, :login]
-            -   append_before_filter :confirm_and_update_start_time,
+            +   append_before_action :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,
+            +   prepend_before_action :reject_announcement_refresh_when_logged_out,
                                       :only => [:announcements]
-            -   before_filter :authenticate_by_ip_address, :only => [:list]
+            +   before_action :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

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

               class MessagesController < ApplicationController
-            -   before_filter :authenticate
+            +   before_action :authenticate
                 verify :method => :post, :only => ['create'],
                        :redirect_to => { :action => 'list' }
                 before_filter :admin_authorization, :only => ['console','show',
                                                               'reply','hide','list_all']
                 def list
                   @user = User.find(session[:user_id])
                   @messages = Message.find_all_sent_by_user(@user)
                 end
                 def console
                   @user = User.find(session[:user_id])
                   @messages = Message.find_all_system_unreplied_messages
                 end
                 def show
                   @message = Message.find(params[:id])
                 end
                 def list_all
                   @user = User.find(session[:user_id])
                   @messages = Message.where(receiver_id: nil).order(:created_at)

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

               require 'csv'
               class ReportController < ApplicationController
-            -   before_filter :authenticate
+            +   before_action :authenticate
-            -   before_filter :admin_authorization, only: [:login_stat,:submission_stat, :stuck, :cheat_report, :cheat_scruntinize, :show_max_score, :current_score]
+            +   before_action :admin_authorization, only: [:login_stat,:submission_stat, :stuck, :cheat_report, :cheat_scruntinize, :show_max_score, :current_score]
-            -   before_filter(only: [:problem_hof]) { |c|
+            +   before_action(only: [:problem_hof]) { |c|
                   return false unless authenticate
                   admin_authorization unless GraderConfiguration["right.user_view_submission"]
                 }
                 def max_score
                 end
                 def current_score
                   @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

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

               class SiteController < ApplicationController
-            -   before_filter :site_admin_authorization, :except => 'login'
+            +   before_action :site_admin_authorization, :except => 'login'
                 def login
                   # Site administrator login
                   @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

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

               class SitesController < ApplicationController
-            -   before_filter :admin_authorization
+            +   before_action :admin_authorization
                 # GET /sites
                 # GET /sites.xml
                 def index
                   @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

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

               class TasksController < ApplicationController
-            -   before_filter :authenticate, :check_viewability
+            +   before_action :authenticate, :check_viewability
                 def index
                   redirect_to :action => 'list'
                 end
                 def list
                   @problems = @user.available_problems
                 end
                 # this has contest-wide access control
                 def view
                   base_name = params[:file]
                   base_filename = File.basename("#{base_name}.#{params[:ext]}")
                   filename = "#{Problem.download_file_basedir}/#{base_filename}"
                   if !FileTest.exists?(filename)
                     redirect_to :action => 'index' and return
                   end
                   send_file_to_user(filename, base_filename)
                 end
                 # this has problem-level access control
                 def download

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

               class TestController < ApplicationController
-            -   before_filter :authenticate, :check_viewability
+            +   before_action :authenticate, :check_viewability
               #
               #  COMMENT OUT: filter in each action instead
               #
               #  before_filter :verify_time_limit, :only => [:submit]
                 verify :method => :post, :only => [:submit],
                        :redirect_to => { :action => :index }
                 def index
                   prepare_index_information
                 end
                 def submit
                   @user = User.find(session[:user_id])
                   @submitted_test_request = TestRequest.new_from_form_params(@user,params[:test_request])
                   if ! @submitted_test_request.errors.empty?
                     prepare_index_information
                     render :action => 'index' and return
                   end
                   if GraderConfiguration.time_limit_mode?

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

               require 'csv'
               class UserAdminController < ApplicationController
                 include MailHelperMethods
-            -   before_filter :admin_authorization
+            +   before_action :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
                   @users = User.all
                   @hidden_columns = ['hashed_password', 'salt', 'created_at', 'updated_at']
                   @contests = Contest.enabled
                 end

app/controllers/users_controller.rb ¶ +4 -4

               require 'net/smtp'
               class UsersController < ApplicationController
                 include MailHelperMethods
-            -   before_filter :authenticate, :except => [:new,
+            +   before_action :authenticate, :except => [:new,
                                                          :register,
                                                          :confirm,
                                                          :forget,
                                                          :retrieve_password]
-            -   before_filter :verify_online_registration, :only => [:new,
+            +   before_action :verify_online_registration, :only => [:new,
                                                                      :register,
                                                                      :forget,
                                                                      :retrieve_password]
-            -   before_filter :authenticate, :profile_authorization, only: [:profile]
+            +   before_action :authenticate, :profile_authorization, only: [:profile]
-            -   before_filter :admin_authorization, only: [:stat, :toggle_activate, :toggle_enable]
+            +   before_action :admin_authorization, only: [:stat, :toggle_activate, :toggle_enable]
                 verify :method => :post, :only => [:chg_passwd],
                        :redirect_to => { :action => :index }
                 #in_place_edit_for :user, :alias_for_editing
                 #in_place_edit_for :user, :email_for_editing
                 def index
                   if !GraderConfiguration['system.user_setting_enabled']
                     redirect_to :controller => 'main', :action => 'list'
                   else
                     @user = User.find(session[:user_id])
                   end
                 end
                 def chg_passwd
                   user = User.find(session[:user_id])
                   user.password = params[:passwd]
                   user.password_confirmation = params[:passwd_verify]
                   if user.save
                     flash[:notice] = 'password changed'
                   else
                     flash[:notice] = 'Error: password changing failed'

config/routes.rb ¶ +2 -1

               CafeGrader::Application.routes.draw do
                 resources :tags
                 get "sources/direct_edit"
                 root :to => 'main#login'
                 #logins
-            -   get 'login/login',  to: 'login#login'
+            +   match 'login/login',  to: 'login#login', via: [:get,:post]
+            +
                 resources :contests
                 resources :sites
                 resources :announcements do
                   member do
                     get 'toggle','toggle_front'
                   end
                 end
                 resources :problems do
                   member do
                     get 'toggle'
                     get 'toggle_test'
                     get 'toggle_view_testcase'
                     get 'stat'
                   end
                   collection do
                     get 'turn_all_off'
                     get 'turn_all_on'
                     get 'import'
                     get 'manage'
                   end

test/integration/login_test.rb ¶ +4 -4

               require 'test_helper'
               class LoginTest < ActionDispatch::IntegrationTest
                 # test "the truth" do
                 #   assert true
                 # end
                 test "login with invalid information" do
                   get root_path
                   assert_response :success
-            -     post login_login_path, login: "root", password: "hahaha"
+            +     post login_login_path, params: {login: "root", password: "hahaha"}
                   assert_redirected_to root_path
                 end
                 test "normal user login" do
                   get root_path
                   assert_response :success
-            -     post login_login_path, {login: "john", password: "hello" }
+            +     post login_login_path, params: {login: "john", password: "hello" }
                   assert_redirected_to main_list_path
                 end
                 test "normal user login in single_user mode" do
                   GraderConfiguration.find_by(key: GraderConfiguration::SINGLE_USER_KEY).update_attributes(value: 'true')
                   GraderConfiguration.reload
                   get root_path
                   assert_response :success
-            -     post login_login_path, {login: "john", password: "hello" }
+            +     post login_login_path, params: {login: "john", password: "hello" }
                   follow_redirect!
                   assert_redirected_to root_path
                 end
                 test "root login in in single_user mode" do
                   GraderConfiguration.find_by(key: GraderConfiguration::SINGLE_USER_KEY).update_attributes(value: 'true')
                   GraderConfiguration.reload
                   get root_path
                   assert_response :success
-            -     post login_login_path, {login: "admin", password: "admin" }
+            +     post login_login_path, params: {login: "admin", password: "admin" }
                   assert_redirected_to main_list_path
                 end
               end

Write
Preview

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

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

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

Sign in to your account

Author

r745:75264caa616f - Wed, 03 Jul 2019 10:25:07 - 20 files changed: 38 inserted, 31 deleted

Sign in to your account

Commit r745:75264caa616f public

Author

r745:75264caa616f - Wed, 03 Jul 2019 10:25:07 - 20 files changed: 38 inserted, 31 deleted

Commit `r745:75264caa616f` public