cafe-grader-web Commit - r783:f1343ca4b141

cafe-grader-web

Commit `r783:f1343ca4b141` public

parent | child

Description:

add ip to front page, also fix seeds.rb

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

r783:f1343ca4b141 - Mon, 04 Nov 2019 07:01:47 - 3 files changed: 3 inserted, 1 deleted

app/controllers/main_controller.rb ¶ +1

               class MainController < ApplicationController
                 before_action :check_valid_login, :except => [:login]
                 before_action :check_viewability, :except => [:index, :login]
                 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_action :reject_announcement_refresh_when_logged_out,
                                       :only => [:announcements]
                 before_action :authenticate_by_ip_address, :only => [:list]
                 #reset login, clear session
                 #front page
                 def login
                   saved_notice = flash[:notice]
                   reset_session
                   flash.now[:notice] = saved_notice
+            +     @remote_ip = request.remote_ip
                   # 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.frontpage
                   render :action => 'login', :layout => 'empty'
                 end
                 def logout
                   reset_session
                   redirect_to root_path
                 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?(@current_user)
                     if @submission.save == false
                       flash[:notice] = 'Error saving your submission'
                     elsif Task.create(:submission_id => @submission.id,
                                       :status => Task::STATUS_INQUEUE) == false
                       flash[:notice] = 'Error adding your submission to task queue'
                     end
                   else
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   redirect_to edit_submission_path(@submission)
                 end
                 def source
                   submission = Submission.find(params[:id])
                   if ((submission.user_id == session[:user_id]) and
                       (submission.problem != nil) and
                       (submission.problem.available))
                     send_data(submission.source,
                               {:filename => submission.download_filename,
                                 :type => 'text/plain'})
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def compiler_msg
                   @submission = Submission.find(params[:id])
                   if @submission.user_id == session[:user_id]
                     render :action => 'compiler_msg', :layout => 'empty'
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def result
                   if !GraderConfiguration.show_grading_result
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   prepare_grading_result(@submission)
                 end
                 def load_output
                   if !GraderConfiguration.show_grading_result or params[:num]==nil
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   case_num = params[:num].to_i
                   out_filename = output_filename(@user.login,
                                                  @submission.problem.name,
                                                  @submission.id,
                                                  case_num)
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   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.published(true)
                   else
                     @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
                     trun_count = grading_info['testruns']
                     trun_count.times do |i|
                       @test_runs << [ read_grading_result(@user.login,
                                                           submission.problem.name,
                                                           submission.id,
                                                           i+1) ]
                     end
                   else
                     grading_info['testruns'].keys.sort.each do |num|
                       run = []
                       testrun = grading_info['testruns'][num]
                       testrun.each do |c|
                         run << read_grading_result(@user.login,
                                                    submission.problem.name,
                                                    submission.id,
                                                    c)
                       end
                       @test_runs << run
                     end
                   end
                 end
                 def grading_result_dir(user_name, problem_name, submission_id, case_num)
                   return "#{GRADING_RESULT_DIR}/#{user_name}/#{problem_name}/#{submission_id}/test-result/#{case_num}"
                 end
                 def output_filename(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   return "#{dir}/output.txt"
                 end
                 def read_grading_result(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   result_file_name = "#{dir}/result"
                   if !FileTest.exists?(result_file_name)
                     return {:num => case_num, :msg => 'program did not run'}
                   else
                     results = File.open(result_file_name).readlines
                     run_stat = extract_running_stat(results)
                     output_filename = "#{dir}/output.txt"
                     if FileTest.exists?(output_filename)
                       output_file = true
                       output_size = File.size(output_filename)
                     else
                       output_file = false
                       output_size = 0
                     end
                     return {
                       :num => case_num,
                       :msg => results[0],
                       :run_stat => run_stat,
                       :output => output_file,
                       :output_size => output_size
                     }
                   end
                 end
                 # copied from grader/script/lib/test_request_helper.rb
                 def extract_running_stat(results)
                   running_stat_line = results[-1]
                   # extract exit status line
                   run_stat = ""
                   if !(/[Cc]orrect/.match(results[0]))
                     run_stat = results[0].chomp
                   else
                     run_stat = 'Program exited normally'
                   end
                   logger.info "Stat line: #{running_stat_line}"
                   # extract running time
                   if res = /r(.*)u(.*)s/.match(running_stat_line)
                     seconds = (res[1].to_f + res[2].to_f)
                     time_stat = "Time used: #{seconds} sec."
                   else
                     seconds = nil
                     time_stat = "Time used: n/a sec."
                   end
                   # extract memory usage
                   if res = /s(.*)m/.match(running_stat_line)
                     memory_used = res[1].to_i
                   else
                     memory_used = -1
                   end
                   return {
                     :msg => "#{run_stat}\n#{time_stat}",
                     :running_time => seconds,
                     :exit_status => run_stat,
                     :memory_usage => memory_used
                   }
                 end
                 def confirm_and_update_start_time
                   user = User.find(session[:user_id])
                   if (GraderConfiguration.indv_contest_mode? and
                       GraderConfiguration['contest.confirm_indv_contest_start'] and
                       !user.contest_started?)
                     redirect_to :action => 'confirm_contest_start' and return
                   end
                   if not GraderConfiguration.analysis_mode?
                     user.update_start_time
                   end
                 end
                 def reject_announcement_refresh_when_logged_out
                   if not session[:user_id]
                     render :text => 'Access forbidden', :status => 403
                   end
                   if GraderConfiguration.multicontests?
                     user = User.find(session[:user_id])
                     if user.contest_stat.forced_logout
                       render :text => 'Access forbidden', :status => 403
                     end
                   end
                 end
               end

app/views/main/login.html.haml ¶ +1

               %h1= GraderConfiguration['ui.front.title']
               .row
                 .col-md-6
                   - if @announcements.length!=0
                     .announcementbox{:style => 'margin-top: 0px'}
                       %span{:class => 'title'}
                         Announcements
                       = render :partial => 'announcement', :collection => @announcements
                 .col-md-4{style: "padding-left: 20px;"}
                   = render :partial => 'login_box'
+            +     = "current ip is #{@remote_ip}"

db/seeds.rb ¶ +1 -1

               CONFIGURATIONS =
                 [
                  {
                    :key => 'system.single_user_mode',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'Only admins can log in to the system when running under single user mode.'
                  },
                  {
                    :key => 'ui.front.title',
                    :value_type => 'string',
                    :default_value => 'Grader'
                  },
                  {
                    :key => 'ui.front.welcome_message',
                    :value_type => 'string',
                    :default_value => 'Welcome!'
                  },
                  {
                    :key => 'ui.show_score',
                    :value_type => 'boolean',
                    :default_value => 'true'
                  },
                  {
                    :key => 'contest.time_limit',
                    :value_type => 'string',
                    :default_value => 'unlimited',
                    :description => 'Time limit in format hh:mm, or "unlimited" for contests with no time limits.  This config is CACHED.  Restart the server before the change can take effect.'
                  },
                  {
                    :key => 'system.mode',
                    :value_type => 'string',
                    :default_value => 'standard',
                    :description => 'Current modes are "standard", "contest", "indv-contest", and "analysis".'
                  },
                  {
                    :key => 'contest.name',
                    :value_type => 'string',
                    :default_value => 'Grader',
                    :description => 'This name will be shown on the user header bar.'
                  },
                  {
                    :key => 'contest.multisites',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'If the server is in contest mode and this option is true, on the log in of the admin a menu for site selections is shown.'
                  },
                  #---------------------------- right --------------------------------
                  {
                    :key => 'right.user_hall_of_fame',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'If true, any user can access hall of fame page.'
                  },
                  {
                    :key => 'right.multiple_ip_login',
                    :value_type => 'boolean',
                    :default_value => 'true',
                    :description => 'When change from true to false, a user can login from the first IP they logged into afterward.'
                  },
                  {
                    :key => 'right.user_view_submission',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'If true, any user can view submissions of every one.'
                  },
                  {
                    :key => 'right.bypass_agreement',
                    :value_type => 'boolean',
                    :default_value => 'true',
                    :description => 'When false, a user must accept usage agreement before login'
                  },
                  {
                    :key => 'right.heartbeat_response',
                    :value_type => 'string',
                    :default_value => 'OK',
                    :description => 'Heart beat response text'
                  },
                  {
                    :key => 'right.heartbeat_response_full',
                    :value_type => 'string',
                    :default_value => 'OK',
                    :description => 'Heart beat response text when user got full score (set this value to the empty string to disable this feature)'
                  },
                  {
                    :key => 'right.view_testcase',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'When true, any user can view/download test data'
                  },
                  {
                    :key => 'system.online_registration',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'This option enables online registration.'
                  },
                  # If Configuration['system.online_registration'] is true, the
                  # system allows online registration, and will use these
                  # information for sending confirmation emails.
                  {
                    :key => 'system.online_registration.smtp',
                    :value_type => 'string',
                    :default_value => 'smtp.somehost.com'
                  },
                  {
                    :key => 'system.online_registration.from',
                    :value_type => 'string',
                    :default_value => 'your.email@address'
                  },
                  {
                    :key => 'system.admin_email',
                    :value_type => 'string',
                    :default_value => 'admin@admin.email'
                  },
                  {
                    :key => 'system.user_setting_enabled',
                    :value_type => 'boolean',
                    :default_value => 'true',
                    :description => 'If this option is true, users can change their settings'
                  },
                  {
                    :key => 'system.user_setting_enabled',
                    :value_type => 'boolean',
                    :default_value => 'true',
                    :description => 'If this option is true, users can change their settings'
                  },
                  # If Configuration['contest.test_request.early_timeout'] is true
                  # the user will not be able to use test request at 30 minutes
                  # before the contest ends.
                  {
                    :key => 'contest.test_request.early_timeout',
                    :value_type => 'boolean',
                    :default_value => 'false'
                  },
                  {
                    :key => 'system.multicontests',
                    :value_type => 'boolean',
                    :default_value => 'false'
                  },
                  {
                    :key => 'contest.confirm_indv_contest_start',
                    :value_type => 'boolean',
                    :default_value => 'false'
                  },
                  {
                    :key => 'contest.default_contest_name',
                    :value_type => 'string',
                    :default_value => 'none',
                    :description => "New user will be assigned to this contest automatically, if it exists.  Set to 'none' if there is no default contest."
                  },
                  {
                    :key => 'system.use_problem_group',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => "If true, available problem to the user will be only ones associated with the group of the user."
                  },
                  {
                    :key => 'right.whitelist_ip_only',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => "If true, non-admin user will be able to use the system only when their ip is in the 'whitelist_ip'."
                  },
                  {
                    :key => 'right.whitelist_ip',
                    :value_type => 'string',
                    :default_value => '0.0.0.0/0',
                    :description => "list of whitelist ip, given in comma separated CIDR notation. For example '161.200.92.0/23, 161.200.80.1/32'"
                  },
                 ]
               def create_configuration_key(key,
                                            value_type,
                                            default_value,
                                            description='')
                 conf = (GraderConfiguration.find_by_key(key) ||
                         GraderConfiguration.new(:key => key,
                                           :value_type => value_type,
                                           :value => default_value))
                 conf.description = description
                 conf.save
               end
               def seed_config
                 CONFIGURATIONS.each do |conf|
                   if conf.has_key? :description
                     desc = conf[:description]
                   else
                     desc = ''
                   end
                   create_configuration_key(conf[:key],
                                            conf[:value_type],
                                            conf[:default_value],
                                            desc)
                 end
               end
               def seed_roles
                 return if Role.find_by_name('admin')
                 role = Role.create(:name => 'admin')
                 user_admin_right = Right.create(:name => 'user_admin',
                                                 :controller => 'user_admin',
                                                 :action => 'all')
                 problem_admin_right = Right.create(:name=> 'problem_admin',
                                                    :controller => 'problems',
                                                    :action => 'all')
                 graders_right = Right.create(:name => 'graders_admin',
                                              :controller => 'graders',
                                              :action => 'all')
                 role.rights << user_admin_right;
                 role.rights << problem_admin_right;
                 role.rights << graders_right;
                 role.save
               end
               def seed_root
                 return if User.find_by_login('root')
                 root = User.new(:login => 'root',
                                 :full_name => 'Administrator',
                                 :alias => 'root')
                 root.password = 'ioionrails';
                 class << root
                   public :encrypt_new_password
                   def valid?(context=nil)
                     true
                   end
                 end
                 root.encrypt_new_password
                 root.roles << Role.find_by_name('admin')
                 root.activated = true
                 root.save
               end
               def seed_users_and_roles
                 seed_roles
                 seed_root
               end
               def seed_more_languages
-            -   Language.delete_all
+            +   #Language.delete_all
                 Language.find_or_create_by( name: 'c', pretty_name: 'C', ext: 'c', common_ext: 'c' )
                 Language.find_or_create_by( name: 'cpp', pretty_name: 'C++', ext: 'cpp', common_ext: 'cpp,cc' )
                 Language.find_or_create_by( name: 'pas', pretty_name: 'Pascal', ext: 'pas', common_ext: 'pas' )
                 Language.find_or_create_by( name: 'ruby', pretty_name: 'Ruby', ext: 'rb', common_ext: 'rb' )
                 Language.find_or_create_by( name: 'python', pretty_name: 'Python', ext: 'py', common_ext: 'py' )
                 Language.find_or_create_by( name: 'java', pretty_name: 'Java', ext: 'java', common_ext: 'java' )
               end
               seed_config
               seed_users_and_roles
               seed_more_languages

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

r783:f1343ca4b141 - Mon, 04 Nov 2019 07:01:47 - 3 files changed: 3 inserted, 1 deleted

Sign in to your account

Commit r783:f1343ca4b141 public

Author

r783:f1343ca4b141 - Mon, 04 Nov 2019 07:01:47 - 3 files changed: 3 inserted, 1 deleted

Commit `r783:f1343ca4b141` public