cafe-grader-web Commit - r696:0b7243db68e6

cafe-grader-web

Commit `r696:0b7243db68e6` public

parent | child

Description:

- after submission, redirecto to edit_submission_path - add more info to submission status - fix bug #20 and #21

Commit status:

[Not Reviewed]

References:

java

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r696:0b7243db68e6 - Wed, 08 Nov 2017 09:13:45 - 11 files changed: 33 inserted, 23 deleted

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

               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.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?(@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 :action => 'list'
+            +     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/controllers/report_controller.rb ¶ +2

               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
                   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
                   #process parameters
                   #problems
                   @problems = []
                   if params[:problem_id]
                     params[:problem_id].each do |id|
                       next unless id.strip != ""
                       pid = Problem.find_by_id(id.to_i)
                       @problems << pid if pid
                     end
                   end
                   #users
                   @users = if params[:user] == "all" then
                              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
+            +     @since_id = nil if @since_id == 0
+            +     @until_id = nil if @until_id == 0
                   #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.available_problems
                   end
                   @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 <= ?",
                                                     user.id,@since_time,@until_time)
                                         .minimum(:created_at),
                                  max: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .maximum(:created_at),
                                   ip: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .select(:ip_address).uniq
                                }
                   end
                 end
                 def submission_stat
                   date_and_time = '%Y-%m-%d %H:%M'
                   begin
                     @since_time = DateTime.strptime(params[:since_datetime],date_and_time)
                   rescue
                     @since_time = DateTime.new(1000,1,1)
                   end
                   begin
                     @until_time = DateTime.strptime(params[:until_datetime],date_and_time)
                   rescue
                     @until_time = DateTime.new(3000,1,1)
                   end
                   @submissions = {}
                   User.find_each do |user|
                     @submissions[user.id] = { login: user.login, full_name: user.full_name, count: 0, sub: { } }
                   end
                   Submission.where("submitted_at >= ? AND submitted_at <= ?",@since_time,@until_time).find_each do |s|
                     if @submissions[s.user_id]
                       if not @submissions[s.user_id][:sub].has_key?(s.problem_id)
                         a = Problem.find_by_id(s.problem_id)
                         @submissions[s.user_id][:sub][s.problem_id] =
                           { prob_name: (a ? a.full_name : '(NULL)'),
                             sub_ids: [s.id] }
                       else
                         @submissions[s.user_id][:sub][s.problem_id][:sub_ids] << s.id
                       end
                       @submissions[s.user_id][:count] += 1
                     end
                   end
                 end
                 def problem_hof
                   # gen problem list
                   @user = User.find(session[:user_id])
                   @problems = @user.available_problems
                   # get selected problems or the default
                   if params[:id]
                     begin
                       @problem = Problem.available.find(params[:id])
                     rescue
                       redirect_to action: :problem_hof
                       flash[:notice] = 'Error: submissions for that problem are not viewable.'
                       return
                     end
                   end
                   return unless @problem
                   @by_lang = {} #aggregrate by language
                   range =65
                   @histogram = { data: Array.new(range,0), summary: {} }
                   @summary = {count: 0, solve: 0, attempt: 0}
                   user = Hash.new(0)
                   Submission.where(problem_id: @problem.id).find_each do |sub|
                     #histogram
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     @histogram[:data][d.to_i] += 1 if d < range
                     next unless sub.points
                     @summary[:count] += 1
                     user[sub.user_id] = [user[sub.user_id], (sub.points >= @problem.full_score) ? 1 : 0].max
                     lang = Language.find_by_id(sub.language_id)
                     next unless lang
                     next unless sub.points >= @problem.full_score
                     #initialize
                     unless @by_lang.has_key?(lang.pretty_name)
                       @by_lang[lang.pretty_name] = {
                         runtime: { avail: false, value: 2**30-1 },
                         memory: { avail: false, value: 2**30-1 },
                         length: { avail: false, value: 2**30-1 },
                         first: { avail: false, value: DateTime.new(3000,1,1) }
                       }
                     end
                     if sub.max_runtime and sub.max_runtime < @by_lang[lang.pretty_name][:runtime][:value]
                       @by_lang[lang.pretty_name][:runtime] = { avail: true, user_id: sub.user_id, value: sub.max_runtime, sub_id: sub.id }
                     end
                     if sub.peak_memory and sub.peak_memory < @by_lang[lang.pretty_name][:memory][:value]
                       @by_lang[lang.pretty_name][:memory] = { avail: true, user_id: sub.user_id, value: sub.peak_memory, sub_id: sub.id }
                     end
                     if sub.submitted_at and sub.submitted_at < @by_lang[lang.pretty_name][:first][:value] and sub.user and
                         !sub.user.admin?
                       @by_lang[lang.pretty_name][:first] = { avail: true, user_id: sub.user_id, value: sub.submitted_at, sub_id: sub.id }
                     end
                     if @by_lang[lang.pretty_name][:length][:value] > sub.effective_code_length
                       @by_lang[lang.pretty_name][:length] = { avail: true, user_id: sub.user_id, value: sub.effective_code_length, sub_id: sub.id }
                     end
                   end
                   #process user_id
                   @by_lang.each do |lang,prop|
                     prop.each do |k,v|
                       v[:user] = User.exists?(v[:user_id]) ? User.find(v[:user_id]).full_name : "(NULL)"
                     end
                   end
                   #sum into best
                   if @by_lang and @by_lang.first
                     @best = @by_lang.first[1].clone
                     @by_lang.each do |lang,prop|
                       if @best[:runtime][:value] >= prop[:runtime][:value]
                         @best[:runtime] = prop[:runtime]
                         @best[:runtime][:lang] = lang
                       end
                       if @best[:memory][:value] >= prop[:memory][:value]
                         @best[:memory] = prop[:memory]
                         @best[:memory][:lang] = lang
                       end
                       if @best[:length][:value] >= prop[:length][:value]
                         @best[:length] = prop[:length]
                         @best[:length][:lang] = lang
                       end
                       if @best[:first][:value] >= prop[:first][:value]
                         @best[:first] = prop[:first]
                         @best[:first][:lang] = lang
                       end
                     end
                   end
                   @histogram[:summary][:max] = [@histogram[:data].max,1].max
                   @summary[:attempt] = user.count
                   user.each_value { |v| @summary[:solve] += 1 if v == 1 }
                 end
                 def stuck #report struggling user,problem
                   # init
                   user,problem = nil
                   solve = true
                   tries = 0
                   @struggle = Array.new
                   record = {}
                   Submission.includes(:problem,:user).order(:problem_id,:user_id).find_each do |sub|
                     next unless sub.problem and sub.user
                     if user != sub.user_id or problem != sub.problem_id
                       @struggle << { user: record[:user], problem: record[:problem], tries: tries } unless solve
                       record = {user: sub.user, problem: sub.problem}
                       user,problem = sub.user_id, sub.problem_id
                       solve = false
                       tries = 0
                     end
                     if sub.points >= sub.problem.full_score
                       solve = true
                     else
                       tries += 1
                     end
                   end
                   @struggle.sort!{|a,b| b[:tries] <=> a[:tries] }
                   @struggle = @struggle[0..50]
                 end
                 def multiple_login
                   #user with multiple IP
                   raw = Submission.joins(:user).joins(:problem).where("problems.available != 0").group("login,ip_address").order(:login)
                   last,count = 0,0
                   first = 0
                   @users = []
                   raw.each do |r|
                     if last != r.user.login
                       count = 1
                       last = r.user.login
                       first = r
                     else
                       @users << first if count == 1
                       @users << r
                       count += 1
                     end
                   end
                   #IP with multiple user
                   raw = Submission.joins(:user).joins(:problem).where("problems.available != 0").group("login,ip_address").order(:ip_address)
                   last,count = 0,0
                   first = 0
                   @ip = []
                   raw.each do |r|
                     if last != r.ip_address
                       count = 1
                       last = r.ip_address
                       first = r
                     else
                       @ip << first if count == 1
                       @ip << r
                       count += 1
                     end
                   end
                 end
                 def cheat_report
                   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 = Time.zone.now.ago( 90.minutes)
                   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 = Time.zone.now
                   end
                   #multi login
                   @ml = Login.joins(:user).where("logins.created_at >= ? and logins.created_at <= ?",@since_time,@until_time).select('users.login,count(distinct ip_address) as count,users.full_name').group("users.id").having("count > 1")
                   st = <<-SQL
                 SELECT l2.*
                   FROM logins l2 INNER JOIN
                   (SELECT u.id,COUNT(DISTINCT ip_address) as count,u.login,u.full_name
                     FROM logins l
                     INNER JOIN users u ON l.user_id =  u.id
                     WHERE l.created_at >= '#{@since_time.in_time_zone("UTC")}' and l.created_at <= '#{@until_time.in_time_zone("UTC")}'
                     GROUP BY u.id
                     HAVING count > 1
                   ) ml ON l2.user_id = ml.id
                   WHERE l2.created_at >= '#{@since_time.in_time_zone("UTC")}' and l2.created_at <= '#{@until_time.in_time_zone("UTC")}'
               UNION
                 SELECT l2.*
                   FROM logins l2 INNER JOIN
                   (SELECT l.ip_address,COUNT(DISTINCT u.id) as count
                     FROM logins l
                     INNER JOIN users u ON l.user_id =  u.id
                     WHERE l.created_at >= '#{@since_time.in_time_zone("UTC")}' and l.created_at <= '#{@until_time.in_time_zone("UTC")}'
                     GROUP BY l.ip_address
                     HAVING count > 1
                   ) ml on ml.ip_address = l2.ip_address
                   INNER JOIN users u ON l2.user_id = u.id
                   WHERE l2.created_at >= '#{@since_time.in_time_zone("UTC")}' and l2.created_at <= '#{@until_time.in_time_zone("UTC")}'
               ORDER BY ip_address,created_at
                             SQL
                   @mld = Login.find_by_sql(st)
                   st = <<-SQL
                 SELECT s.id,s.user_id,s.ip_address,s.submitted_at,s.problem_id
                   FROM submissions s INNER JOIN
                   (SELECT u.id,COUNT(DISTINCT ip_address) as count,u.login,u.full_name
                     FROM logins l
                     INNER JOIN users u ON l.user_id =  u.id
                     WHERE l.created_at >= ? and l.created_at <= ?
                     GROUP BY u.id
                     HAVING count > 1
                   ) ml ON s.user_id = ml.id
                   WHERE s.submitted_at >= ? and s.submitted_at <= ?
               UNION
                 SELECT s.id,s.user_id,s.ip_address,s.submitted_at,s.problem_id
                   FROM submissions s INNER JOIN
                   (SELECT l.ip_address,COUNT(DISTINCT u.id) as count
                     FROM logins l
                     INNER JOIN users u ON l.user_id =  u.id
                     WHERE l.created_at >= ? and l.created_at <= ?
                     GROUP BY l.ip_address
                     HAVING count > 1
                   ) ml on ml.ip_address = s.ip_address
                   WHERE s.submitted_at >= ? and s.submitted_at <= ?
               ORDER BY ip_address,submitted_at
                           SQL
                   @subs = Submission.joins(:problem).find_by_sql([st,@since_time,@until_time,
                                                      @since_time,@until_time,
                                                      @since_time,@until_time,
                                                      @since_time,@until_time])
                 end
                 def cheat_scruntinize
                   #convert date & time
                   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 = Time.zone.now.ago( 90.minutes)
                   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 = Time.zone.now
                   end
                   #convert sid
                   @sid = params[:SID].split(/[,\s]/) if params[:SID]
                   unless @sid and @sid.size > 0
                     return
                     redirect_to actoin: :cheat_scruntinize
                     flash[:notice] = 'Please enter at least 1 student id'
                   end
                   mark = Array.new(@sid.size,'?')
                   condition = "(u.login = " + mark.join(' OR u.login = ') + ')'
                   @st = <<-SQL

app/helpers/application_helper.rb ¶ +7 -4

               # Methods added to this helper will be available to all templates in the application.
               module ApplicationHelper
                 #new bootstrap header
                 def navbar_user_header
                   left_menu = ''
                   right_menu = ''
                   user = User.find(session[:user_id])
                   if (user!=nil) and (GraderConfiguration.show_tasks_to?(user))
                     left_menu << add_menu("#{I18n.t 'menu.tasks'}", 'tasks', 'list')
                     left_menu << add_menu("#{I18n.t 'menu.submissions'}", 'main', 'submission')
                     left_menu << add_menu("#{I18n.t 'menu.test'}", 'test', 'index')
                   end
                   if GraderConfiguration['right.user_hall_of_fame']
                     left_menu << add_menu("#{I18n.t 'menu.hall_of_fame'}", 'report', 'problem_hof')
                   end
                   right_menu << add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-question-sign')}".html_safe, 'main', 'help')
                   right_menu << add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-comment')}".html_safe, 'messages', 'list', {title: I18n.t('menu.messages'), data: {toggle: 'tooltip'}})
                   if GraderConfiguration['system.user_setting_enabled']
                     right_menu << add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-cog')}".html_safe, 'users', 'index', {title: I18n.t('menu.settings'), data: {toggle: 'tooltip'}})
                   end
                   right_menu << add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-log-out')} #{user.full_name}".html_safe, 'main', 'login', {title: I18n.t('menu.log_out'), data: {toggle: 'tooltip'}})
                   result = content_tag(:ul,left_menu.html_safe,class: 'nav navbar-nav') + content_tag(:ul,right_menu.html_safe,class: 'nav navbar-nav navbar-right')
                 end
                 def add_menu(title, controller, action, html_option = {})
                   link_option = {controller: controller, action: action}
                   html_option[:class] = (html_option[:class] || '') + " active" if current_page?(link_option)
                   content_tag(:li, link_to(title,link_option),html_option)
                 end
                 def user_header
                   menu_items = ''
                   user = User.find(session[:user_id])
                   if (user!=nil) and (session[:admin])
                     # admin menu
                     menu_items << "<b>Administrative task:</b> "
                     append_to menu_items, '[Announcements]', 'announcements', 'index'
                     append_to menu_items, '[Msg console]', 'messages', 'console'
                     append_to menu_items, '[Problems]', 'problems', 'index'
                     append_to menu_items, '[Users]', 'user_admin', 'index'
                     append_to menu_items, '[Results]', 'user_admin', 'user_stat'
                     append_to menu_items, '[Report]', 'report', 'multiple_login'
                     append_to menu_items, '[Graders]', 'graders', 'list'
                     append_to menu_items, '[Contests]', 'contest_management', 'index'
                     append_to menu_items, '[Sites]', 'sites', 'index'
                     append_to menu_items, '[System config]', 'configurations', 'index'
                     menu_items << "<br/>"
                   end
                   # main page
                   append_to menu_items, "[#{I18n.t 'menu.main'}]", 'main', 'list'
                   append_to menu_items, "[#{I18n.t 'menu.messages'}]", 'messages', 'list'
                   if (user!=nil) and (GraderConfiguration.show_tasks_to?(user))
                     append_to menu_items, "[#{I18n.t 'menu.tasks'}]", 'tasks', 'list'
                     append_to menu_items, "[#{I18n.t 'menu.submissions'}]", 'main', 'submission'
                     append_to menu_items, "[#{I18n.t 'menu.test'}]", 'test', 'index'
                   end
                   if GraderConfiguration['right.user_hall_of_fame']
                     append_to menu_items, "[#{I18n.t 'menu.hall_of_fame'}]", 'report', 'problem_hof'
                   end
                   append_to menu_items, "[#{I18n.t 'menu.help'}]", 'main', 'help'
                   if GraderConfiguration['system.user_setting_enabled']
                     append_to menu_items, "[#{I18n.t 'menu.settings'}]", 'users', 'index'
                   end
                   append_to menu_items, "[#{I18n.t 'menu.log_out'}]", 'main', 'login'
                   menu_items.html_safe
                 end
                 def append_to(option,label, controller, action)
                   option << ' ' if option!=''
                   option << link_to_unless_current(label,
                                                    :controller => controller,
                                                    :action => action)
                 end
                 def format_short_time(time)
-            -     now = Time.now.gmtime
+            +     now = Time.zone.now
                   st = ''
-            -     if (time.yday != now.yday) or
-            - 	(time.year != now.year)
-            -       st = time.strftime("%x ")
+            +     if (time.yday != now.yday) or (time.year != now.year)
+            +       st = time.strftime("%d/%m/%y ")
                   end
                   st + time.strftime("%X")
                 end
                 def format_short_duration(duration)
                   return '' if duration==nil
                   d = duration.to_f
                   return Time.at(d).gmtime.strftime("%X")
                 end
+            +   def format_full_time_ago(time)
+            +     st = time_ago_in_words(time) + ' ago (' + format_short_time(time) + ')'
+            +   end
+            +
                 def read_textfile(fname,max_size=2048)
                   begin
                     File.open(fname).read(max_size)
                   rescue
                     nil
                   end
                 end
                 def toggle_button(on,toggle_url,id, option={})
                   btn_size = option[:size] || 'btn-xs'
                   link_to (on ? "Yes" : "No"), toggle_url,
                     {class: "btn btn-block #{btn_size} btn-#{on ? 'success' : 'default'} ajax-toggle",
                       id: id,
                       data: {remote: true, method: 'get'}}
                 end
                 def get_ace_mode(language)
                   # return ace mode string from Language
                   case language.pretty_name
                     when 'Pascal'
                       'ace/mode/pascal'
                     when 'C++','C'
                       'ace/mode/c_cpp'
                     when 'Ruby'
                       'ace/mode/ruby'
                     when 'Python'
                       'ace/mode/python'
                     when 'Java'
                       'ace/mode/java'
                     else
                       'ace/mode/c_cpp'
                   end
                 end
                 def user_title_bar(user)
                   header = ''
                   time_left = ''
                   #
                   # if the contest is over
                   if GraderConfiguration.time_limit_mode?
                     if user.contest_finished?
                       header = <<CONTEST_OVER
               <tr><td colspan="2" align="center">
               <span class="contest-over-msg">THE CONTEST IS OVER</span>
               </td></tr>
               CONTEST_OVER
                     end
                     if !user.contest_started?
                       time_left = "&nbsp;&nbsp;" + (t 'title_bar.contest_not_started')
                     else
                       time_left = "&nbsp;&nbsp;" + (t 'title_bar.remaining_time') +
                         " #{format_short_duration(user.contest_time_left)}"
                     end
                   end
                   #
                   # if the contest is in the anaysis mode
                   if GraderConfiguration.analysis_mode?
                     header = <<ANALYSISMODE
               <tr><td colspan="2" align="center">
               <span class="contest-over-msg">ANALYSIS MODE</span>
               </td></tr>
               ANALYSISMODE
                   end
                   contest_name = GraderConfiguration['contest.name']
                   #
                   # build real title bar
                   result = <<TITLEBAR
               <div class="title">
               <table>
               #{header}
               <tr>
               <td class="left-col">
               #{user.full_name}<br/>
               #{t 'title_bar.current_time'} #{format_short_time(Time.zone.now)}
               #{time_left}
               <br/>
               </td>
               <td class="right-col">#{contest_name}</td>
               </tr>
               </table>
               </div>
               TITLEBAR
                   result.html_safe
                 end
                 def markdown(text)
                   markdown = RDiscount.new(text)
                   markdown.to_html.html_safe
                 end
                 BOOTSTRAP_FLASH_MSG = {
                   success: 'alert-success',
                   error: 'alert-danger',
                   alert: 'alert-danger',
                   notice: 'alert-info'
                 }
                 def bootstrap_class_for(flash_type)
                   BOOTSTRAP_FLASH_MSG.fetch(flash_type.to_sym, flash_type.to_s)
                 end
                 def flash_messages
                   flash.each do |msg_type, message|
                     concat(content_tag(:div, message, class: "alert #{bootstrap_class_for(msg_type)} fade in") do
                             concat content_tag(:button, 'x', class: "close", data: { dismiss: 'alert' })
                             concat message
                           end)
                   end
                   nil
                 end
               end

app/models/submission.rb ¶ +2 -2

               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
                 has_one :task
                 before_save :assign_latest_number_if_new_recond
                 def self.find_last_by_user_and_problem(user_id, problem_id)
                   where("user_id = ? AND problem_id = ?",user_id,problem_id).last
                 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 = records.where('id >= ?',since_id) if since_id and since_id > 0
+            +     records = records.where('id <= ?',until_id) if until_id and until_id > 0
                   records.all
                 end
                 def self.find_last_for_all_available_problems(user_id)
                   submissions = Array.new
                   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)
                   where("user_id = ? AND problem_id = ? AND number = ?",user_id,problem_id,number).first
                 end
                 def self.find_all_by_user_problem(user_id, problem_id)
                   where("user_id = ? AND problem_id = ?",user_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)
                     return problem
                   else
                     if source_filename
                       return Problem.find_by_name(source_filename.split('.').first)
                     else
                       return nil
                     end
                   end
                 end
                 def assign_problem
                   if self.problem_id!=-1
                     begin
                       self.problem = Problem.find(self.problem_id)
                     rescue ActiveRecord::RecordNotFound
                       self.problem = nil
                     end
                   else
                     self.problem = Submission.find_problem_in_source(self.source,
                                                                      self.source_filename)
                   end
                 end
                 def assign_language
                   self.language = Submission.find_language_in_source(self.source,
                                                                      self.source_filename)
                 end
                 # validation codes
                 def must_specify_language
                   return if self.source==nil
                   # for output_only tasks
                   return if self.problem!=nil and self.problem.output_only
                   if self.language==nil
                     errors.add('source',"Cannot detect language. Did you submit a correct source file?") unless self.language!=nil
                   end
                 end
                 def must_have_valid_problem
                   return if self.source==nil
                   if self.problem==nil
                     errors.add('problem',"must be specified.")
                   else
                     #admin always have right
                     return if self.user.admin?
                     #check if user has the right to submit the problem
                     errors.add('problem',"must be valid.") if (!self.user.available_problems.include?(self.problem)) and (self.new_record?)
                   end
                 end
                 # callbacks
                 def assign_latest_number_if_new_recond
                   return if !self.new_record?
                   latest = Submission.find_last_by_user_and_problem(self.user_id, self.problem_id)
                   self.number = (latest==nil) ? 1 : latest.number + 1;
                 end
               end

app/views/application/_submission_short.html.haml ¶ +11 -9

+            -
-              - if submission.nil?
                 = "-"
               - else
+            +   %strong= "Submission ID:"
+            +   = submission.id
+            +   %br
                 - unless submission.graded_at
-            -     = t 'main.submitted_at'
-            -     = format_short_time(submission.submitted_at.localtime)
+            +     %strong= t 'main.submitted_at:'
+            +     = format_full_time_ago(submission.submitted_at.localtime)
                 - else
-            -     %strong= t 'main.graded_at'
-            -     = "#{format_short_time(submission.graded_at.localtime)} "
+            +     %strong= t 'main.graded_at:'
+            +     = format_full_time_ago(submission.graded_at.localtime)
                   %br
                   - if GraderConfiguration['ui.show_score']
                     %strong=t 'main.score'
                     = "#{(submission.points*100/submission.problem.full_score).to_i} "
                   = " ["
                   %tt
                     = submission.grader_comment
                   = "]"
                   %br
-            -     %strong View:
-            -     - if GraderConfiguration.show_grading_result
-            -       = link_to '[detailed result]', :action => 'result', :id => submission.id
-            -     = link_to "#{t 'main.cmp_msg'}", {:action => 'compiler_msg', :id => submission.id}, {popup: true,class: 'btn btn-xs btn-info'}
+            +   %strong View:
+            +   - if GraderConfiguration.show_grading_result
+            +     = link_to '[detailed result]', :action => 'result', :id => submission.id
+            +   = link_to "#{t 'main.cmp_msg'}", {:action => 'compiler_msg', :id => submission.id}, {popup: true,class: 'btn btn-xs btn-info'} if submission.graded_at
                 = link_to "#{t 'main.src_link'}", download_submission_path(submission.id), class: 'btn btn-xs btn-info'
                 = link_to "#{t 'main.submissions_link'}", problem_submissions_path(problem_id), class: 'btn btn-xs btn-info'

app/views/report/max_score.html.haml ¶ +2 -2

               %h1 Maximum score
               = form_tag report_show_max_score_path
               .row
                 .col-md-4
                   .panel.panel-primary
                     .panel-heading
                       Problems
                     .panel-body
                       %p
                         Select problem(s) that we wish to know the score.
                       = label_tag :problem_id, "Problems"
                       = select_tag 'problem_id[]',
                           options_for_select(Problem.all.collect {|p| ["[#{p.name}] #{p.full_name}", p.id]},params[:problem_id]),
                           { class: 'select2 form-control', multiple: "true" }
                 .col-md-4
                   .panel.panel-primary
                     .panel-heading
                       Submission range
                     .panel-body
                       %p
                         Input minimum and maximum range of submission ID that should be included. A blank value for min and max means -1 and infinity, respectively.
                       .form-group
                         = label_tag :from, "Min"
                         = text_field_tag 'from_id', @since_id, class: "form-control"
                       .form-group
                         = label_tag :from, "Max"
                         = text_field_tag 'to_id', @until_id, class: "form-control"
                 .col-md-4
                   .panel.panel-primary
                     .panel-heading
                       Users
                     .panel-body
                       .radio
                         %label
-            -             = radio_button_tag 'users', 'all', true
+            +             = radio_button_tag 'users', 'all', (params[:users] == "all")
                           All users
                       .radio
                         %label
-            -             = radio_button_tag 'users', 'enabled'
+            +             = radio_button_tag 'users', 'enabled', (params[:users] == "enabled")
                           Only enabled users
               .row
                 .col-md-12
                   = button_tag 'Show', class: "btn btn-primary btn-large", value: "show"
                   = button_tag 'Download CSV', class: "btn btn-primary btn-large", value: "download"
               - if @scorearray
                 %h2 Result
                 =render "score_table"

app/views/submissions/edit.html.haml ¶ +1 -1

               %h2 Live submit
               %br
               %textarea#text_sourcecode{style: "display:none"}~ @source
               .container
                 .row
                   .col-md-12
                     .alert.alert-info
                       Write your code in the following box, choose language, and click submit button when finished
                 .row
                   .col-md-8
                     %div#editor{style: 'height: 500px; border-radius: 7px; font-size: 14px;'}
                   .col-md-4
                     - # submission form
                     = form_tag({controller: :main, :action => 'submit'}, :multipart => true, class: 'form') do
                       = hidden_field_tag 'editor_text', @source
                       = hidden_field_tag 'submission[problem_id]', @problem.id
                       .form-group
                         = label_tag "Task:"
                         = text_field_tag 'asdf', "#{@problem.long_name}", class: 'form-control', disabled: true
                       .form-group
                         = label_tag 'Language'
                         = select_tag 'language_id', options_from_collection_for_select(Language.all, 'id', 'pretty_name', @lang_id || Language.find_by_pretty_name("Python").id || Language.first.id), class: 'form-control select', style: "width: 100px"
                       .form-group
                         = submit_tag 'Submit', class: 'btn btn-success', id: 'live_submit',
                           data: {confirm: "Submitting this source code for task #{@problem.long_name}?"}
                     - # latest submission status
-            -       .panel.panel-info
+            +       .panel{class: (@submission && @submission.graded_at) ? "panel-info" : "panel-warning"}
                       .panel-heading
                         Latest Submission Status
                         = link_to "Refresh",get_latest_submission_status_submissions_path(@submission.user,@problem), class: "btn btn-default btn-sm", remote: true if @submission
                       .panel-body
                         - if @submission
                           = render :partial => 'submission_short',
                             :locals => {submission: @submission, problem_name: @problem.name, problem_id: @problem.id }
                 .row
                   .col-md-12
                     %h2 Console
                     %textarea#console{style: 'height: 100%; width: 100%;background-color:#000;color:#fff;font-family: consolas, monaco, "Droid Sans Mono";',rows: 20}
               :javascript
                 $(document).ready(function() {
                   e = ace.edit("editor")
                   e.setValue($("#text_sourcecode").val());
                   e.gotoLine(1);
                   $("#language_id").trigger('change');
                   brython();
                 });
               %script#__main__{type:'text/python3'}
                 :plain
                   import sys
                   import traceback
                   from browser import document as doc
                   from browser import window, alert, console
                   _credits = """    Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
                       for supporting Python development.  See www.python.org for more information."""
                   _copyright = """Copyright (c) 2012, Pierre Quentel pierre.quentel@gmail.com
                   All Rights Reserved.
                   Copyright (c) 2001-2013 Python Software Foundation.
                   All Rights Reserved.
                   Copyright (c) 2000 BeOpen.com.
                   All Rights Reserved.
                   Copyright (c) 1995-2001 Corporation for National Research Initiatives.
                   All Rights Reserved.
                   Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
                   All Rights Reserved."""
                   _license = """Copyright (c) 2012, Pierre Quentel pierre.quentel@gmail.com
                   All rights reserved.
                   Redistribution and use in source and binary forms, with or without
                   modification, are permitted provided that the following conditions are met:
                   Redistributions of source code must retain the above copyright notice, this
                   list of conditions and the following disclaimer. Redistributions in binary
                   form must reproduce the above copyright notice, this list of conditions and
                   the following disclaimer in the documentation and/or other materials provided
                   with the distribution.
                   Neither the name of the <ORGANIZATION> nor the names of its contributors may
                   be used to endorse or promote products derived from this software without
                   specific prior written permission.
                   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
                   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
                   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
                   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
                   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
                   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
                   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
                   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
                   POSSIBILITY OF SUCH DAMAGE.
                   """
                   def credits():
                       print(_credits)
                   credits.__repr__ = lambda:_credits
                   def copyright():
                       print(_copyright)
                   copyright.__repr__ = lambda:_copyright
                   def license():
                       print(_license)
                   license.__repr__ = lambda:_license
                   def write(data):
                       doc['console'].value += str(data)
                   sys.stdout.write = sys.stderr.write = write
                   history = []
                   current = 0
                   _status = "main"  # or "block" if typing inside a block
                   # execution namespace
                   editor_ns = {'credits':credits,
                       'copyright':copyright,
                       'license':license,
                       '__name__':'__main__'}
                   def cursorToEnd(*args):
                       pos = len(doc['console'].value)
                       doc['console'].setSelectionRange(pos, pos)
                       doc['console'].scrollTop = doc['console'].scrollHeight
                   def get_col(area):
                       # returns the column num of cursor
                       sel = doc['console'].selectionStart
                       lines = doc['console'].value.split('\n')
                       for line in lines[:-1]:
                           sel -= len(line) + 1
                       return sel
                   def myKeyPress(event):
                       global _status, current
                       if event.keyCode == 9:  # tab key
                           event.preventDefault()
                           doc['console'].value += "    "
                       elif event.keyCode == 13:  # return
                           src = doc['console'].value
                           if _status == "main":
                               currentLine = src[src.rfind('>>>') + 4:]
                           elif _status == "3string":
                               currentLine = src[src.rfind('>>>') + 4:]
                               currentLine = currentLine.replace('\n... ', '\n')
                           else:
                               currentLine = src[src.rfind('...') + 4:]
                           if _status == 'main' and not currentLine.strip():
                               doc['console'].value += '\n>>> '
                               event.preventDefault()
                               return
                           doc['console'].value += '\n'
                           history.append(currentLine)
                           current = len(history)
                           if _status == "main" or _status == "3string":
                               try:
                                   _ = editor_ns['_'] = eval(currentLine, editor_ns)
                                   if _ is not None:
                                       write(repr(_)+'\n')
                                   doc['console'].value += '>>> '
                                   _status = "main"
                               except IndentationError:
                                   doc['console'].value += '... '
                                   _status = "block"
                               except SyntaxError as msg:
                                   if str(msg) == 'invalid syntax : triple string end not found' or \
                                       str(msg).startswith('Unbalanced bracket'):
                                       doc['console'].value += '... '
                                       _status = "3string"
                                   elif str(msg) == 'eval() argument must be an expression':
                                       try:
                                           exec(currentLine, editor_ns)
                                       except:
                                           traceback.print_exc()
                                       doc['console'].value += '>>> '
                                       _status = "main"
                                   elif str(msg) == 'decorator expects function':
                                       doc['console'].value += '... '
                                       _status = "block"
                                   else:
                                       traceback.print_exc()
                                       doc['console'].value += '>>> '
                                       _status = "main"
                               except:
                                   traceback.print_exc()
                                   doc['console'].value += '>>> '
                                   _status = "main"
                           elif currentLine == "":  # end of block
                               block = src[src.rfind('>>>') + 4:].splitlines()
                               block = [block[0]] + [b[4:] for b in block[1:]]
                               block_src = '\n'.join(block)
                               # status must be set before executing code in globals()
                               _status = "main"
                               try:
                                   _ = exec(block_src, editor_ns)
                                   if _ is not None:
                                       print(repr(_))
                               except:
                                   traceback.print_exc()
                               doc['console'].value += '>>> '
                           else:
                               doc['console'].value += '... '
                           cursorToEnd()
                           event.preventDefault()
                   def myKeyDown(event):
                       global _status, current
                       if event.keyCode == 37:  # left arrow
                           sel = get_col(doc['console'])
                           if sel < 5:
                               event.preventDefault()
                               event.stopPropagation()
                       elif event.keyCode == 36:  # line start
                           pos = doc['console'].selectionStart
                           col = get_col(doc['console'])
                           doc['console'].setSelectionRange(pos - col + 4, pos - col + 4)
                           event.preventDefault()
                       elif event.keyCode == 38:  # up
                           if current > 0:
                               pos = doc['console'].selectionStart
                               col = get_col(doc['console'])
                               # remove current line
                               doc['console'].value = doc['console'].value[:pos - col + 4]
                               current -= 1
                               doc['console'].value += history[current]
                           event.preventDefault()
                       elif event.keyCode == 40:  # down
                           if current < len(history) - 1:
                               pos = doc['console'].selectionStart
                               col = get_col(doc['console'])
                               # remove current line
                               doc['console'].value = doc['console'].value[:pos - col + 4]
                               current += 1
                               doc['console'].value += history[current]
                           event.preventDefault()
                       elif event.keyCode == 8:  # backspace
                           src = doc['console'].value
                           lstart = src.rfind('\n')
                           if (lstart == -1 and len(src) < 5) or (len(src) - lstart < 6):
                               event.preventDefault()
                               event.stopPropagation()
                   doc['console'].bind('keypress', myKeyPress)
                   doc['console'].bind('keydown', myKeyDown)
                   doc['console'].bind('click', cursorToEnd)
                   v = sys.implementation.version
                   doc['console'].value = "Brython %s.%s.%s on %s %s\n>>> " % (
                       v[0], v[1], v[2], window.navigator.appName, window.navigator.appVersion)
                   #doc['console'].value += 'Type "copyright", "credits" or "license" for more information.'
                   doc['console'].focus()
                   cursorToEnd()

config/application.rb.SAMPLE ¶ +1 -1

               require File.expand_path('../boot', __FILE__)
               require 'rails/all'
               if defined?(Bundler)
                 # If you precompile assets before deploying to production, use this line
                 Bundler.require(*Rails.groups(:assets => %w(development test)))
                 # If you want your assets lazily compiled in production, use this line
                 # Bundler.require(:default, :assets, Rails.env)
               end
               module CafeGrader
                 class Application < Rails::Application
                   # Settings in config/environments/* take precedence over those specified here.
                   # Application configuration should go into files in config/initializers
                   # -- all .rb files in that directory are automatically loaded.
                   # Custom directories with classes and modules you want to be autoloadable.
                   config.autoload_paths += %W(#{config.root}/lib)
                   # Only load the plugins named here, in the order given (default is alphabetical).
                   # :all can be used as a placeholder for all plugins not explicitly named.
                   # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
                   # Activate observers that should always be running.
                   # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
                   # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
                   # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
                   config.time_zone = 'UTC'
                   # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
                   # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
                   config.i18n.default_locale = :en
                   # Configure the default encoding used in templates for Ruby 1.9.
                   config.encoding = "utf-8"
                   # Configure sensitive parameters which will be filtered from the log file.
                   config.filter_parameters += [:password]
                   # Enable escaping HTML in JSON.
                   config.active_support.escape_html_entities_in_json = true
                   # Use SQL instead of Active Record's schema dumper when creating the database.
                   # This is necessary if your schema can't be completely dumped by the schema dumper,
                   # like if you have constraints or database-specific column types
                   # config.active_record.schema_format = :sql
                   # Enable the asset pipeline
                   config.assets.enabled = true
                   # Version of your assets, change this if you want to expire all your assets
                   config.assets.version = '1.0'
                   # ---------------- IMPORTANT ----------------------
                   # If we deploy the app into a subdir name "grader", be sure to do "rake assets:precompile RAILS_RELATIVE_URL_ROOT=/grader"
                   # moreover, using the following line instead also known to works
                   #config.action_controller.relative_url_root = '/grader'
                   #font path
                   config.assets.paths << "#{Rails}/vendor/assets/fonts"
                   config.assets.precompile += ['announcement_refresh.js','effects.js','site_update.js']
                   config.assets.precompile += ['local_jquery.js','tablesorter-theme.cafe.css']
                   %w( announcements submissions configurations contests contest_management graders heartbeat
                       login main messages problems report site sites sources tasks
-            -         test user_admin users ).each do |controller|
+            +         test user_admin users testcases).each do |controller|
                     config.assets.precompile += ["#{controller}.js", "#{controller}.css"]
                   end
                 end
               end

config/initializers/assets.rb ¶ +1 -1

               # Be sure to restart your server when you modify this file.
               # Version of your assets, change this if you want to expire all your assets.
               Rails.application.config.assets.version = '1.0'
               # Add additional assets to the asset load path.
               # Rails.application.config.assets.paths << Emoji.images_path
               # Add Yarn node_modules folder to the asset load path.
               Rails.application.config.assets.paths << Rails.root.join('node_modules')
               Rails.application.config.assets.paths << Rails.root.join('vendor/assets/fonts')
               # Precompile additional assets.
               # application.js, application.css, and all non-JS/CSS in the app/assets
               # folder are already added.
               # Rails.application.config.assets.precompile += %w( admin.js admin.css )
               Rails.application.config.assets.precompile += ['announcement_refresh.js','effects.js','site_update.js']
               Rails.application.config.assets.precompile += ['local_jquery.js','tablesorter-theme.cafe.css']
               %w( announcements submissions configurations contests contest_management graders heartbeat
                   login main messages problems report site sites sources tasks groups
-            -     test user_admin users tags).each do |controller|
+            +     test user_admin users tags testcases).each do |controller|
                 Rails.application.config.assets.precompile += ["#{controller}.js", "#{controller}.css"]
               end

lib/grader_script.rb ¶ +1

               module GraderScript
                 def self.grader_control_enabled?
                   if defined? GRADER_ROOT_DIR
                     GRADER_ROOT_DIR != ''
                   else
                     false
                   end
                 end
                 def self.raw_dir
                   File.join GRADER_ROOT_DIR, "raw"
                 end
                 def self.call_grader(params)
                   if GraderScript.grader_control_enabled?
                     cmd = File.join(GRADER_ROOT_DIR, "scripts/grader") + " " + params
                     system(cmd)
                   end
                 end
                 def self.stop_grader(pid)
                   GraderScript.call_grader "stop #{pid}"
                 end
                 def self.stop_graders(pids)
                   pid_str = (pids.map { |process| process.pid.to_s }).join ' '
                   GraderScript.call_grader "stop #{pid_str}"
                 end
                 def self.start_grader(env)
                   GraderScript.call_grader "#{env} queue --err-log &"
                   GraderScript.call_grader "#{env} test_request -err-log &"
                 end
+            +   #call the import problem script
                 def self.call_import_problem(problem_name,
                                              problem_dir,
                                              time_limit=1,
                                              memory_limit=32,
                                              checker_name='text')
                   if GraderScript.grader_control_enabled?
                     cur_dir = `pwd`.chomp
                     Dir.chdir(GRADER_ROOT_DIR)
                     script_name = File.join(GRADER_ROOT_DIR, "scripts/import_problem")
                     cmd = "#{script_name} #{problem_name} #{problem_dir} #{checker_name}" +
                       " -t #{time_limit} -m #{memory_limit}"
                     output = `#{cmd}`
                     Dir.chdir(cur_dir)
                     return "import CMD: #{cmd}\n" + output
                   end
                   return ''
                 end
                 def self.call_import_testcase(problem_name)
                   if GraderScript.grader_control_enabled?
                     cur_dir = `pwd`.chomp
                     Dir.chdir(GRADER_ROOT_DIR)
                     script_name = File.join(GRADER_ROOT_DIR, "scripts/load_testcase")
                     cmd = "#{script_name} #{problem_name}"
                     output = `#{cmd}`
                     Dir.chdir(cur_dir)
                     return "Testcase import result:\n" + output
                   end
                 end
               end

lib/testdata_importer.rb ¶ +4 -2

               require 'tmpdir'
               class TestdataImporter
                 attr :log_msg
                 def initialize(problem)
                   @problem = problem
                 end
-            -   def import_from_file(tempfile,
-            -                        time_limit,
+            +   #Create or update problem according to the parameter
+            +   def import_from_file(tempfile,
+            +                        time_limit,
                                      memory_limit,
                                      checker_name='text',
                                      import_to_db=false)
                   dirname = extract(tempfile)
                   return false if not dirname
                   if not import_to_db
                     @log_msg = GraderScript.call_import_problem(@problem.name,
                                                                 dirname,
                                                                 time_limit,
                                                                 memory_limit,
                                                                 checker_name)
                   else
                     # Import test data to test pairs.
                     @problem.test_pairs.clear
                     if import_test_pairs(dirname)
                       test_pair_count = TestPair.count :conditions => "problem_id = #{@problem.id}"
                       @log_msg = "Importing test pair successful. (#{test_pair_count} test pairs imported)"
                     else
                       @log_msg = "Importing test pair failed. (0 test pairs imported)"
                     end
                   end
                   @log_msg << import_problem_description(dirname)
                   @log_msg << import_problem_pdf(dirname)
                   @log_msg << import_full_score(dirname)
                   #import test data
                   @log_msg << GraderScript.call_import_testcase(@problem.name)
                   return true
                 end
                 protected
                 def self.long_ext(filename)
                   i = filename.index('.')
                   len = filename.length
                   return filename.slice(i..len)
                 end
+            +   # extract an archive file located at +tempfile+ to the +raw_dir+
                 def extract(tempfile)
                   testdata_filename = save_testdata_file(tempfile)
                   ext = TestdataImporter.long_ext(tempfile.original_filename)
                   extract_dir = File.join(GraderScript.raw_dir, @problem.name)
                   if File.exists? extract_dir
                     backup_count = 0
                     begin
                       backup_count += 1
                       backup_dirname = "#{extract_dir}.backup.#{backup_count}"
                     end while File.exists? backup_dirname
                     File.rename(extract_dir, backup_dirname)
                   end
                   Dir.mkdir extract_dir
                   if ext=='.tar.gz' or ext=='.tgz'
                     cmd = "tar -zxvf #{testdata_filename} -C #{extract_dir}"
                   elsif ext=='.tar'
                     cmd = "tar -xvf #{testdata_filename} -C #{extract_dir}"
                   elsif ext=='.zip'
                     cmd = "unzip -o #{testdata_filename} -d #{extract_dir}"
                   else
                     return nil
                   end
                   system(cmd)
                   files = Dir["#{extract_dir}/**/*1*.in"]
                   return nil if files.length==0
                   File.delete(testdata_filename)
                   return File.dirname(files[0])
                 end
                 def save_testdata_file(tempfile)
                   ext = TestdataImporter.long_ext(tempfile.original_filename)
                   testdata_filename = File.join(Dir.tmpdir,"#{@problem.name}#{ext}")
                   return nil if tempfile==""
                   if tempfile.instance_of?(Tempfile)
                     tempfile.close
                     FileUtils.move(tempfile.path,testdata_filename)
                   else
                     File.open(testdata_filename, "wb") do |f|
                       f.write(tempfile.read)
                     end
                   end
                   return testdata_filename
                 end
                 def import_test_pairs(dirname)
                   test_num = 1
                   while FileTest.exists? "#{dirname}/#{test_num}.in"
                     in_filename = "#{dirname}/#{test_num}.in"
                     sol_filename = "#{dirname}/#{test_num}.sol"
                     break if not FileTest.exists? sol_filename
                     test_pair = TestPair.new(:input => open(in_filename).read,
                                              :solution => open(sol_filename).read,
                                              :problem => @problem)
                     break if not test_pair.save
                     test_num += 1
                   end
                   return test_num > 1
                 end
                 def import_problem_description(dirname)
                   html_files = Dir["#{dirname}/*.html"]
                   markdown_files = Dir["#{dirname}/*.md"] + Dir["#{dirname}/*.markdown"]
                   if (html_files.length != 0) or (markdown_files.length != 0)
                     description = @problem.description || Description.new
                     if html_files.length != 0
                       filename = html_files[0]
                       description.markdowned = false
                     else
                       filename = markdown_files[0]
                       description.markdowned = true
                     end
                     description.body = open(filename).read
                     description.save
                     @problem.description = description
                     @problem.save
                     return "\nProblem description imported from #{filename}."
                   else
                     return ''
                   end
                 end
                 def import_problem_pdf(dirname)
                   pdf_files = Dir["#{dirname}/*.pdf"]
                   puts "CHECKING... #{dirname}"
                   if pdf_files.length != 0
                     puts "HAS PDF FILE"
                     filename = pdf_files[0]
                     @problem.save if not @problem.id
                     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.rename(filename, out_filename)
                     @problem.description_filename = "#{@problem.name}.pdf"
                     @problem.save
                     return "\nProblem pdf imported from #{filename}."
                   else
                     return ""
                   end
                 end
                 #just set the full score to the total number of test case
                 #it is not perfect but works on most normal use case
                 def import_full_score(dirname)
                   num = 0
                   loop do
                     num += 1
                     in_file = Dir["#{dirname}/#{num}*.in"]
                     break if in_file.length == 0
                   end
                   full_score = (num - 1) * 10
                   @problem.full_score = full_score
                   @problem.save
                   return "\nFull score is set to #{full_score}."
                 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

r696:0b7243db68e6 - Wed, 08 Nov 2017 09:13:45 - 11 files changed: 33 inserted, 23 deleted

Sign in to your account

Commit r696:0b7243db68e6 public

Author

r696:0b7243db68e6 - Wed, 08 Nov 2017 09:13:45 - 11 files changed: 33 inserted, 23 deleted

Commit `r696:0b7243db68e6` public