cafe-grader-web Commit - r855:ef5cd5528b8d

cafe-grader-web

Commit `r855:ef5cd5528b8d` public

parent | child

Description:

add model solution

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

r855:ef5cd5528b8d - Fri, 04 Feb 2022 15:55:30 - 11 files changed: 210 inserted, 125 deleted

db/migrate/20220204080936_add_type_to_submission.rb created 644 ¶ +6

@@ -0,0 +1,6
	1	+ class AddTypeToSubmission < ActiveRecord::Migration[7.0]
	2	+ def change
	3	+ add_column :submissions, :tag, :integer, default: 0
	4	+ add_column :problems, :difficulty, :integer
	5	+ end
	6	+ end

app/controllers/application_controller.rb ¶ +11

               require 'ipaddr'
               require "securerandom"
               class ApplicationController < ActionController::Base
                 protect_from_forgery
                 before_action :current_user
                 before_action :nav_announcement
                 before_action :unique_visitor_id
                 SINGLE_USER_MODE_CONF_KEY = 'system.single_user_mode'
                 MULTIPLE_IP_LOGIN_CONF_KEY = 'right.multiple_ip_login'
                 WHITELIST_IGNORE_CONF_KEY = 'right.whitelist_ignore'
                 WHITELIST_IP_CONF_KEY = 'right.whitelist_ip'
                 #report and redirect for unauthorized activities
                 def unauthorized_redirect(notice = 'You are not authorized to view the page you requested')
                   flash[:notice] = notice
                   redirect_to login_main_path
                 end
                 # Returns the current logged-in user (if any).
                 def current_user
                   return nil unless session[:user_id]
                   @current_user ||= User.find(session[:user_id])
                 end
                 def nav_announcement
                   @nav_announcement = Announcement.where(on_nav_bar: true)
                 end
                 def admin_authorization
                   return false unless check_valid_login
                   user = User.includes(:roles).find(session[:user_id])
                   unless user.admin?
                     unauthorized_redirect
                     return false
                   end
                   return true
                 end
+            +   #admin always count as every roles
+            +   def role_authorization(roles)
+            +     return false unless check_valid_login
+            +     user = User.find(session[:user_id])
+            +     return true if user.admin?
+            +     roles.each do |r|
+            +       return true if user.has_role?(r)
+            +     end
+            +     unauthorized_redirect
+            +   end
+            +
                 def authorization_by_roles(allowed_roles)
                   return false unless check_valid_login
                   unless @current_user.roles.detect { |role| allowed_roles.member?(role.name) }
                     unauthorized_redirect
                     return false
                   end
                 end
                 def testcase_authorization
                   #admin always has privileged
                   if @current_user.admin?
                     return true
                   end
                   unauthorized_redirect unless GraderConfiguration["right.view_testcase"]
                 end
                 def unique_visitor_id
                   unless cookies.encrypted[:uuid]
                     value = SecureRandom.uuid
                     cookies.encrypted[:uuid] = { value: value, expires: 20.year }
                   end
                   puts "encrypt " + cookies.encrypted[:uuid]
                   puts cookies[:uuid]
                 end
                 protected
                 #redirect to root (and also force logout)
                 #if the user is not logged_in or the system is in "ADMIN ONLY" mode
                 def check_valid_login
                   #check if logged in
                   unless session[:user_id]
                     if GraderConfiguration[SINGLE_USER_MODE_CONF_KEY]
                       unauthorized_redirect('You need to login but you cannot log in at this time')
                     else
                       unauthorized_redirect('You need to login')
                     end
                     return false
                   end
                   # check if run in single user mode
                   if GraderConfiguration[SINGLE_USER_MODE_CONF_KEY]
                     if @current_user==nil || (!@current_user.admin?)
                       unauthorized_redirect('You cannot log in at this time')
                       return false
                     end
                   end

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

                   # 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
+            +     @submission.ip_address = cookies.encrypted[:uuid]
                   if @current_user.admin? == false && GraderConfiguration.time_limit_mode? && @current_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

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

                   case params[:users]
                   when 'enabled'
                     @submissions = @submissions.where(users: {enabled: true})
                   when 'group'
                     @submissions = @submissions.joins(user: :groups).where(user: {groups: {id: params[:groups]}}) if params[:groups]
                   end
                   case params[:problems]
                   when 'enabled'
                     @submissions = @submissions.where(problems: {available: true})
                   when 'selected'
                     @submissions = @submissions.where(problem_id: params[:problem_id])
                   end
                   #set default
                   params[:since_datetime] = Date.today.to_s if params[:since_datetime].blank?
                   @submissions, @recordsTotal, @recordsFiltered = process_query_record( @submissions,
                     global_search: ['user.login','user.full_name','problem.name','problem.full_name','points'],
                     date_filter: 'submitted_at',
                     date_param_since: 'since_datetime',
                     date_param_until: 'until_datetime',
                     hard_limit: 100_000
                   )
                 end
                 def login
                 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
+            +     #model submisssion
+            +     @model_subs = Submission.where(problem: @problem,tag: Submission.tags[:model])
+            +
+            +
+            +     #calculate best submission
                   @by_lang = {} #aggregrate by language
                   range =65
-            -     @histogram = { data: Array.new(range,0), summary: {} }
+            +     #@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
+            +       #@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
+            +     #@histogram[:summary][:max] = [@histogram[:data].max,1].max
                   @summary[:attempt] = user.count
                   user.each_value { |v| @summary[:solve] += 1 if v == 1 }
+            +
+            +
+            +     #for new graph
+            +     @chart_dataset = @problem.get_jschart_history.to_json.html_safe
                 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

app/controllers/submissions_controller.rb ¶ +11 -7

               class SubmissionsController < ApplicationController
+            +   before_action :set_submission, only: [:show,:download,:compiler_msg,:rejudge,:set_tag, :edit]
                 before_action :check_valid_login
                 before_action :submission_authorization, only: [:show, :download, :edit]
-            -   before_action :admin_authorization, only: [:rejudge]
+            +   before_action only: [:rejudge, :set_tag] do role_authorization([:ta]) end
                 # GET /submissions
                 # GET /submissions.json
                 # Show problem selection and user's submission of that problem
                 def index
                   @user = @current_user
                   @problems = @user.available_problems
                   if params[:problem_id]==nil
                     @problem = nil
                     @submissions = nil
                   else
                     @problem = Problem.find_by_id(params[:problem_id])
                     if (@problem == nil) or (not @problem.available)
                       redirect_to list_main_path
                       flash[:error] = 'Authorization error: You have no right to view submissions for this problem'
                       return
                     end
                     @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id).order(id: :desc)
                   end
                 end
                 # GET /submissions/1
                 # GET /submissions/1.json
                 def show
-            -     @submission = Submission.find(params[:id])
                   #log the viewing
                   user = User.find(session[:user_id])
                   SubmissionViewLog.create(user_id: session[:user_id],submission_id: @submission.id) unless user.admin?
                   @task = @submission.task
                 end
                 def download
-            -     @submission = Submission.find(params[:id])
                   send_data(@submission.source, {:filename => @submission.download_filename, :type => 'text/plain'})
                 end
                 def compiler_msg
-            -     @submission = Submission.find(params[:id])
                   respond_to do |format|
                     format.js
                   end
                 end
                 #on-site new submission on specific problem
                 def direct_edit_problem
                   @problem = Problem.find(params[:problem_id])
                   unless @current_user.can_view_problem?(@problem)
                     unauthorized_redirect
                     return
                   end
                   @source = ''
                   if (params[:view_latest])
                     sub = Submission.find_last_by_user_and_problem(@current_user.id,@problem.id)
                     @source = @submission.source.to_s if @submission and @submission.source
                   end
                   render 'edit'
                 end
                 # GET /submissions/1/edit
                 def edit
-            -     @submission = Submission.find(params[:id])
                   @source = @submission.source.to_s
                   @problem = @submission.problem
                   @lang_id = @submission.language.id
                 end
                 def get_latest_submission_status
                   @problem = Problem.find(params[:pid])
                   @submission = Submission.find_last_by_user_and_problem(params[:uid],params[:pid])
                   respond_to do |format|
                     format.js
                   end
                 end
                 # GET /submissions/:id/rejudge
                 def rejudge
-            -     @submission = Submission.find(params[:id])
                   @task = @submission.task
                   @task.status_inqueue! if @task
                   respond_to do |format|
                     format.js
                   end
                 end
+            +   def set_tag
+            +     @submission.update(tag: params[:tag])
+            +     redirect_to @submission
+            +   end
+            +
               protected
                 def submission_authorization
                   #admin always has privileged
                   return true if @current_user.admin?
                   return true if @current_user.has_role?('ta') && (['show','download'].include? action_name)
                   sub = Submission.find(params[:id])
                   if @current_user.available_problems.include? sub.problem
                     return true if GraderConfiguration["right.user_view_submission"] or sub.user == @current_user
                   end
                   #default to NO
                   unauthorized_redirect
                   return false
                 end
+            +
+            +   def set_submission
+            +     @submission = Submission.find(params[:id])
+            +   end
               end

app/models/problem.rb ¶ +22

               class Problem < ActiveRecord::Base
                 belongs_to :description
                 has_and_belongs_to_many :contests, :uniq => true
                 #has_and_belongs_to_many :groups
                 has_many :groups_problems, class_name: 'GroupProblem'
                 has_many :groups, :through => :groups_problems
                 has_many :problems_tags, class_name: 'ProblemTag'
                 has_many :tags, through: :problems_tags
                 has_many :test_pairs, :dependent => :delete_all
                 has_many :testcases, :dependent => :destroy
                 has_many :submissions
                 validates_presence_of :name
                 validates_format_of :name, :with => /\A\w+\z/
                 validates_presence_of :full_name
                 scope :available, -> { where(available: true) }
                 DEFAULT_TIME_LIMIT = 1
                 DEFAULT_MEMORY_LIMIT = 32
+            +   def get_jschart_history
+            +     start = 4.month.ago.beginning_of_day
+            +     start_date = start.to_date
+            +     count = Submission.where(problem: self).where('submitted_at >= ?', start).group('DATE(submitted_at)').count
+            +     i = 0
+            +     label = []
+            +     value = []
+            +     while (start_date + i < Time.zone.now.to_date)
+            +       if (start_date+i).day == 1
+            +         #label << (start_date+i).strftime("%d %b %Y")
+            +         #label << (start_date+i).strftime("%d")
+            +       else
+            +         #label << ' '
+            +         #label << (start_date+i).strftime("%d")
+            +       end
+            +       label << (start_date+i).strftime("%d-%b")
+            +       value << (count[start_date+i] || 0)
+            +       i+=1
+            +     end
+            +     return {labels: label,datasets: [label:'sub',data: value, backgroundColor: 'rgba(54, 162, 235, 0.2)', borderColor: 'rgb(75, 192, 192)']}
+            +   end
+            +
                 def self.available_problems
                   available.order(date_added: :desc).order(:name)
                   #Problem.available.all(:order => "date_added DESC, name ASC")
                 end
                 def self.create_from_import_form_params(params, old_problem=nil)
                   org_problem = old_problem || Problem.new
                   import_params, problem = Problem.extract_params_and_check(params,
                                                                             org_problem)
                   if !problem.errors.empty?
                     return problem, 'Error importing'
                   end
                   problem.full_score = 100
                   problem.date_added = Time.new
                   problem.test_allowed = true
                   problem.output_only = false
                   problem.available = false
                   if not problem.save
                     return problem, 'Error importing'
                   end
                   import_to_db = params.has_key? :import_to_db
                   importer = TestdataImporter.new(problem)
                   if not importer.import_from_file(import_params[:file],
                                                    import_params[:time_limit],
                                                    import_params[:memory_limit],
                                                    import_params[:checker_name],
                                                    import_to_db)
                     problem.errors.add(:base,'Import error.')
                   end
                   return problem, importer.log_msg
                 end
                 def self.download_file_basedir
                   return "#{Rails.root}/data/tasks"
                 end
                 def get_submission_stat
                   result = Hash.new
                   #total number of submission
                   result[:total_sub] = Submission.where(problem_id: self.id).count
                   result[:attempted_user] = Submission.where(problem_id: self.id).group(:user_id)

app/models/submission.rb ¶ +11 -9

               class Submission < ActiveRecord::Base
+            +   enum tag: {default: 0, model: 1}, _prefix: true
+            +
                 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 => 'code too long, the limit is 100,000 bytes'
                 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 = " +
+            +       "WHERE id = " +
-            - 			   "(SELECT MAX(id) FROM submissions AS subs " +
+            +         "(SELECT MAX(id) FROM submissions AS subs " +
-            - 			   "WHERE subs.user_id = submissions.user_id AND " +
+            +       "WHERE subs.user_id = submissions.user_id AND " +
-            -                            "problem_id = " + problem_id.to_s + " " +
+            +         "problem_id = " + problem_id.to_s + " " +
-            - 			   "GROUP BY user_id) " +
+            +       "GROUP BY user_id) " +
-            -                            "ORDER 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 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
+            +         words = s.split
-            - 	return words[1]
+            +         return words[1]
                     end
                     i = i + 1
                     if i==10
-            - 	return nil
+            +         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
                   if self.language == nil
                     self.language = Submission.find_language_in_source(self.source,

app/views/report/_task_hof.html.haml ¶ +116 -98

@@ -1,136 +1,154
1	:css	1	:css
2	.hof_user { color: orangered; font-style: italic; }	2	.hof_user { color: orangered; font-style: italic; }
3	.hof_language { color: green; font-style: italic; }	3	.hof_language { color: green; font-style: italic; }
4	.hof_value { color: deeppink;font-style: italic; }	4	.hof_value { color: deeppink;font-style: italic; }
5	.info_param { font-weight: bold;text-align: right; }	5	.info_param { font-weight: bold;text-align: right; }
6	.tooltip {	6	.tooltip {
7	font-family: Verdana,sans-serif;	7	font-family: Verdana,sans-serif;
8	font-weight: normal;	8	font-weight: normal;
9	text-align: left;	9	text-align: left;
10	font-size: 1.0em;	10	font-size: 1.0em;
11	color: black;	11	color: black;
12	line-height: 1.1;	12	line-height: 1.1;
13	display: none;	13	display: none;
14	min-width: 20em;	14	min-width: 20em;
15	position: absolute;	15	position: absolute;
16	left: 25px;	16	left: 25px;
17	bottom: 5px;	17	bottom: 5px;
18	border: 1px solid;	18	border: 1px solid;
19	padding: 5px;	19	padding: 5px;
20	background-color: #FFF;	20	background-color: #FFF;
21	word-wrap: break-word;	21	word-wrap: break-word;
22	z-index: 9999;	22	z-index: 9999;
23	overflow: auto;	23	overflow: auto;
24	}	24	}
25		25
26		26
27	- .container	27	+ .container-fluid
		28	+ .row
		29	+ .col-md-8
		30	+ .card
		31	+ .card-body
		32	+ %h2.card-title Submission History
		33	+ %canvas#chart{height: '50px'}
		34	+
		35	+ .col-md-4
		36	+ .card
		37	+ .card-body
		38	+ %h2.card-title General Info
		39	+ .row
		40	+ .col-sm-6
		41	+ Subs
		42	+ .col-sm-6
		43	+ = @summary[:count]
		44	+ .row
		45	+ .col-sm-6
		46	+ Solved/Attempted User
		47	+ .col-sm-6
		48	+ #{@summary[:solve]}/#{@summary[:attempt]} (#{(@summary[:solve]*100.0/@summary[:attempt]).round(1)}%)
28	.row	49	.row
29	.col-md-4	50	.col-md-4
30	- %h2 Overall Stat	51	+ .card
31	- %table.table.table-hover	52	+ .card-body
32	- %thead	53	+ %h2.card-title Model submission
33	- %tr
34	- %th
35	- %th
36	- %tbody
37	- %tr
38	- %td.info_param Submissions
39	- %td= @summary[:count]
40	- %tr
41	- %td.info_param Solved/Attempted User
42	- %td #{@summary[:solve]}/#{@summary[:attempt]} (#{(@summary[:solve]*100.0/@summary[:attempt]).round(1)}%)
43	- - if @best
44	- %tr
45	- %td.info_param Best Runtime
46	- %td
47	- by #{link_to @best[:runtime][:user], stat_user_path(@best[:runtime][:user_id])}
48	- %br
49	- using <span class="text-success">#{@best[:runtime][:lang]}</span>
50	- %br
51	- with <span class="text-success">#{@best[:runtime][:value] * 1000} milliseconds</span>
52	- %br
53	- at submission
54	- = link_to "#" + @best[:runtime][:sub_id].to_s, submission_path(@best[:runtime][:sub_id])
55	-
56	- %tr
57	- %td.info_param
58	- Best Memory Usage
59	- %sup{ id: "xmem_remark",
60	- style: "position:relative; color: blue;",
61	- data: {toggle: 'tooltip', placement: 'top', animation: 'false', delay: 20},
62	- title: "This counts only for submission with 100% score. Right now, java is excluded from memory usage competition. (Because it always uses 2GB memory...)"}
63	- [?]
64	- %td
65	- by #{link_to @best[:memory][:user], stat_user_path(@best[:memory][:user_id])}
66	- %br
67	- using <span class="text-success">#{@best[:memory][:lang]}</span>
68	- %br
69	- with <span class="text-success">#{number_with_delimiter(@best[:memory][:value])} kbytes </span>
70	- %br
71	- at submission
72	- = link_to "#" + @best[:memory][:sub_id].to_s, submission_path(@best[:memory][:sub_id])
73	-
74	- %tr
75	- %td.info_param Shortest Code
76	- %td
77	- by #{link_to @best[:length][:user], stat_user_path(@best[:length][:user_id])}
78	- %br
79	- using <span class="text-success">#{@best[:length][:lang]}</span>
80	- %br
81	- with <span class="text-success">#{@best[:length][:value]} bytes</span>
82	- %br
83	- at submission
84	- = link_to "#" + @best[:length][:sub_id].to_s, submission_path(@best[:length][:sub_id])
85	-
86	- %tr
87	- %td.info_param First solver
88	- %td
89	- - if @best[:first][:user] != '(NULL)'
90	- #{link_to @best[:first][:user], stat_user_path(@best[:first][:user_id])} is the first solver
91	- %br
92	- using <span class="text-success">#{@best[:first][:lang]}</span>
93	- %br
94	- on <span class="text-success">#{@best[:first][:value]}</span>
95	- %br
96	- at submission
97	- = link_to "#" + @best[:first][:sub_id].to_s, submission_path( @best[:first][:sub_id])
98	- - else
99	- no first solver
100	- .col-md-8
101	- - if @best
102	- %h2 By Language
103	%table.table.table-hover	54	%table.table.table-hover
104	%thead	55	%thead
105	%tr	56	%tr
106	- %th ~~Language~~	57	+ %th #Sub
107	- %th ~~Best runtime (ms)~~	58	+ %th Author
108	- %th Best memory (kbytes)
109	- %th Shortest Code (bytes)
110	- %th First solver
111	%tbody	59	%tbody
112	- - @~~by_lang~~.each do \|~~lang~~,~~value~~\|	60	+ - @model_subs.each do \|sub\|
113	%tr	61	%tr
114	- %td= lang	62	+ %td= link_to "##{sub.id}", submission_path(sub)
		63	+ %td= sub.user.full_name
		64	+ .col-md-8
		65	+ - if @best
		66	+ .card
		67	+ .card-body
		68	+ %h2.card-title Top Submissions
		69	+ %table.table.table-hover
		70	+ %thead
		71	+ %tr
		72	+ %th Language
		73	+ %th Best runtime (ms)
		74	+ %th Best memory (kbytes)
		75	+ %th Shortest Code (bytes)
		76	+ %th First solver
		77	+ %tbody
		78	+ %tr.bg-warning
115	%td	79	%td
116	- = link_to value[:runtime][:user], stat_user_path(value[:runtime][:user_id])	80	+ Overall
		81	+ %td
		82	+ by #{link_to @best[:runtime][:user], stat_user_path(@best[:runtime][:user_id])}
		83	+ %br
		84	+ using <span class="text-success">#{@best[:runtime][:lang]}</span>
		85	+ %br
		86	+ with <span class="text-success">#{@best[:runtime][:value] * 1000} milliseconds</span>
		87	+ %br= link_to "#" + @best[:runtime][:sub_id].to_s, submission_path(@best[:runtime][:sub_id])
		88	+ %td
		89	+ by #{link_to @best[:memory][:user], stat_user_path(@best[:memory][:user_id])}
117	%br	90	%br
118	- = "#{(value[:runtime][:value] * 1000).to_i} @"	91	+ using <span class="text-success">#{@best[:memory][:lang]}</span>
119	- = link_to "#" + value[:runtime][:sub_id].to_s, submission_path( value[:runtime][:sub_id])	92	+ %br
		93	+ with <span class="text-success">#{number_with_delimiter(@best[:memory][:value])} kbytes </span>
		94	+ %br= link_to "#" + @best[:memory][:sub_id].to_s, submission_path(@best[:memory][:sub_id])
		95	+ %td
		96	+ by #{link_to @best[:length][:user], stat_user_path(@best[:length][:user_id])}
		97	+ %br
		98	+ using <span class="text-success">#{@best[:length][:lang]}</span>
		99	+ %br
		100	+ with <span class="text-success">#{@best[:length][:value]} bytes</span>
		101	+ %br= link_to "#" + @best[:length][:sub_id].to_s, submission_path(@best[:length][:sub_id])
120	%td	102	%td
121	- = link_to value[:memory][:user], stat_user_path( value[:memory][:user_id])	103	+ - if @best[:first][:user] != '(NULL)'
122	- %br	104	+ #{link_to @best[:first][:user], stat_user_path(@best[:first][:user_id])} is the first solver
123	- = "#{number_with_delimiter(value[:memory][:value])} @"	105	+ %br
124	- = link_to "#" + value[:memory][:sub_id].to_s, submission_path(value[:memory][:sub_id])	106	+ using <span class="text-success">#{@best[:first][:lang]}</span>
125	- ~~%td~~	107	+ %br
126	- = link_to value[:length][:user], stat_user_path(value[:length][:user_id])	108	+ on <span class="text-success">#{@best[:first][:value]}</span>
127	- %br	109	+ %br= link_to "#" + @best[:first][:sub_id].to_s, submission_path( @best[:first][:sub_id])
128	- = "#{value[:length][:value]} @"	110	+ - else
129	- = link_to "#" + value[:length][:sub_id].to_s, submission_path(value[:length][:sub_id])	111	+ no first solver
130	- %td	112	+ - @by_lang.each do \|lang,value\|
131	- - if value[:first][:user] != '(NULL)' #TODO: i know... this is wrong...	113	+ %tr
132	- = link_to value[:first][:user], stat_user_path(value[:first][:user_id])	114	+ %td= lang
		115	+ %td
		116	+ = link_to value[:runtime][:user], stat_user_path(value[:runtime][:user_id])
		117	+ %br
		118	+ = "#{(value[:runtime][:value] * 1000).to_i} @"
		119	+ = link_to "#" + value[:runtime][:sub_id].to_s, submission_path( value[:runtime][:sub_id])
		120	+ %td
		121	+ = link_to value[:memory][:user], stat_user_path( value[:memory][:user_id])
		122	+ %br
		123	+ = "#{number_with_delimiter(value[:memory][:value])} @"
		124	+ = link_to "#" + value[:memory][:sub_id].to_s, submission_path(value[:memory][:sub_id])
		125	+ %td
		126	+ = link_to value[:length][:user], stat_user_path(value[:length][:user_id])
133	%br	127	%br
134	- = "#{value[:~~first~~][:value]} @"	128	+ = "#{value[:length][:value]} @"
135	- = link_to "#" + value[:~~first~~][:sub_id].to_s, submission_path( value[:~~first~~][:sub_id])	129	+ = link_to "#" + value[:length][:sub_id].to_s, submission_path(value[:length][:sub_id])
		130	+ %td
		131	+ - if value[:first][:user] != '(NULL)' #TODO: i know... this is wrong...
		132	+ = link_to value[:first][:user], stat_user_path(value[:first][:user_id])
		133	+ %br
		134	+ = "#{value[:first][:value]} @"
		135	+ = link_to "#" + value[:first][:sub_id].to_s, submission_path( value[:first][:sub_id])
136		136
		137	+ %script{src:"https://cdn.jsdelivr.net/npm/chart.js"}
		138	+ :javascript
		139	+ data = #{@chart_dataset}
		140	+ config = {
		141	+ type: 'bar',
		142	+ data: data,
		143	+ options: {
		144	+ plugins: {
		145	+ legend: {
		146	+ display: false
		147	+ },
		148	+ },
		149	+ }
		150	+ }
		151	+ Chart.defaults.font.size = 15
		152	+ //Chart.defaults.font.family = 'Sarabun Light'
		153	+ chart = new Chart($('#chart'),config)
		154	+

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

               /- if params[:id]
               /  %h1 Tasks Hall of Fame
               /  = link_to('[back to All-Time Hall of Fame]', action: 'problem_hof', id: nil  )
               /- else
               /  %h1 All-Time Hall of Fame
               .panel.panel-info
                 .panel-heading
                   Select Task
                 .panel-body
                   .form-inline
                     = select 'report',
                       'problem_id',
                       @problems.collect {|p| ["[#{p.name}] #{p.full_name}", problem_hof_report_path(p)]},
                       {:selected => problem_hof_report_path(@problem)},
                       { class: 'select2 form-control' }
                     %button.btn.btn-primary.btn-sm.go-button#problem_go{data: {source: "#report_problem_id"}} Go
               - unless params[:id]
                 /=render partial: 'all_time_hof'
                 Please select a problem.
               - else
                 %h1 [#{Problem.find(params[:id]).name}] #{Problem.find(params[:id]).full_name}
-            -   %h2 Submission History
+            +   -# %h2 Submission History
-            -   =render partial: 'application/bar_graph', locals: { histogram: @histogram }
+            +   -# =render partial: 'application/bar_graph', locals: { histogram: @histogram }
                 =render partial: 'task_hof'

app/views/submissions/show.html.haml ¶ +17 -5

                         %td
                           - if @submission.problem!=nil
                             = link_to "[#{@submission.problem.name}]", stat_problem_path(@submission.problem)
                             = @submission.problem.full_name
                             = link_to_description_if_any "[download] <span class='glyphicon glyphicon-file'></span>".html_safe, @submission.problem
                           - else
                             = "(n/a)"
                       %tr
                         %td.text-right
                           %strong Tries
                         %td= @submission.number
                       %tr
                         %td.text-right
                           %strong Language
                         %td= @submission.language.pretty_name
                       %tr
                         %td.text-right
                           %strong Submitted
                         %td #{time_ago_in_words(@submission.submitted_at)} ago (at #{@submission.submitted_at.to_formatted_s(:long)})
                       %tr
                         %td.text-right
                           %strong Graded
                         - if @submission.graded_at
                           %td #{time_ago_in_words(@submission.graded_at)} ago (at #{@submission.graded_at.to_formatted_s(:long)})
                         - else
                           %td -
                       %tr
                         %td.text-right
                           %strong Points
                         %td #{@submission.points}/#{@submission.try(:problem).try(:full_score)}
                       %tr
                         %td.text-right
                           %strong Comment
                         %td #{@submission.grader_comment}
                       %tr
                         %td.text-right
                           %strong Runtime (s)
                         %td #{@submission.max_runtime}
                       %tr
                         %td.text-right
                           %strong Memory (kb)
                         %td #{@submission.peak_memory}
                       %tr
                         %td.text-right
                           %strong Compiler result
                         %td
                           %button.btn.btn-info.btn-xs{type: 'button', data: {toggle: 'modal', target: '#compiler'}}
                             view
-            -         - if session[:admin]
-            -           %tr
-            -             %td.text-right
-            -               %strong IP
-            -             %td #{@submission.ip_address}
                       %tr
                         %td.text-right
                           %strong Grading Task Status
                         %td
                           = @task.status_str if @task
                           - if session[:admin]
                             = link_to "rejudge", rejudge_submission_path, data: {remote: true}, class: 'btn btn-info btn-xs'
+            +         - if session[:admin]
+            +           %tr
+            +             %td.text-right
+            +               %strong IP
+            +             %td #{@submission.ip_address}
+            +           %tr
+            +             %td.text-right
+            +               %strong Model solution
+            +             %td
+            +               - if @submission.tag_model?
+            +                 YES
+            +                 - if session[:admin]
+            +                   = link_to "remove model status", set_tag_submission_path(@submission, tag: :default), class: 'btn btn-warning btn-xs'
+            +               - else
+            +                 No
+            +                 - if session[:admin]
+            +                   = link_to "set as model solution", set_tag_submission_path(@submission, tag: :model), class: 'btn btn-success btn-xs'
               .modal.fade#compiler{tabindex: -1,role: 'dialog'}
                 .modal-dialog.modal-lg{role:'document'}
                   .modal-content
                     .modal-header
                       %button.close{type: 'button', data: {dismissed: :modal}, aria: {label: 'close'}}
                         %span{aria: {hidden: 'true'}, data: {dismiss: 'modal'}} &times;
                       %h4 Compiler message
                     .modal-body
                       %pre#compiler_msg= @submission.compiler_message
                     .modal-footer
                       %button.btn.btn-default{type: 'button', data: {dismiss: 'modal'}} Close

config/routes.rb ¶ +1

                 resources :groups do
                   member do
                     post 'add_user', to: 'groups#add_user', as: 'add_user'
                     delete 'remove_user/:user_id', to: 'groups#remove_user', as: 'remove_user'
                     delete 'remove_all_user', to: 'groups#remove_all_user', as: 'remove_all_user'
                     post 'add_problem', to: 'groups#add_problem', as: 'add_problem'
                     delete 'remove_problem/:problem_id', to: 'groups#remove_problem', as: 'remove_problem'
                     delete 'remove_all_problem', to: 'groups#remove_all_problem', as: 'remove_all_problem'
                     get 'toggle'
                   end
                   collection do
                   end
                 end
                 resources :testcases, only: [] do
                   member do
                     get 'download_input'
                     get 'download_sol'
                   end
                   collection do
                     get 'show_problem/:problem_id(/:test_num)' => 'testcases#show_problem', as: 'show_problem'
                   end
                 end
                 resources :grader_configuration, controller: 'configurations' do
                   collection do
                     get 'set_exam_right(/:value)', action: 'set_exam_right', as: 'set_exam_right'
                   end
                 end
                 resources :users do
                   member do
                     get 'toggle_activate', 'toggle_enable'
                     get 'stat'
                   end
                   collection do
                     get 'profile'
                     post 'chg_passwd'
                     post 'chg_default_language'
                   end
                 end
                 resources :submissions do
                   member do
                     get 'download'
                     get 'compiler_msg'
                     get 'rejudge'
+            +       get 'set_tag'
                   end
                   collection do
                     get 'prob/:problem_id', to: 'submissions#index', as: 'problem'
                     get 'direct_edit_problem/:problem_id(/:user_id)', to: 'submissions#direct_edit_problem', as: 'direct_edit_problem'
                     get 'get_latest_submission_status/:uid/:pid', to: 'submissions#get_latest_submission_status', as: 'get_latest_submission_status'
                   end
                 end
                 #user admin
                 resources :user_admin  do
                   collection do
                     match 'bulk_manage', via: [:get, :post]
                     get 'bulk_mail'
                     get 'user_stat'
                     get 'import'
                     get 'new_list'
                     get 'admin'
                     get 'active'
                     get 'mass_mailing'
                     match 'modify_role', via: [:get, :post]
                     match 'create_from_list', via: [:get, :post]
                     match 'random_all_passwords', via: [:get, :post]
                   end
                   member do
                     get 'clear_last_ip'
                   end
                 end
                 resources :contest_management, only: [:index] do
                   collection do
                     get 'user_stat'
                     get 'clear_stat'
                     get 'clear_all_stat'
                     get 'change_contest_mode'
                   end
                 end
                 #get 'user_admin', to: 'user_admin#index'
                 #get 'user_admin/bulk_manage', to: 'user_admin#bulk_manage', as: 'bulk_manage_user_admin'
                 #post 'user_admin', to: 'user_admin#create'
                 #delete 'user_admin/:id', to: 'user_admin#destroy', as: 'user_admin_destroy'
                 #singular resource
                 #---- BEWARE ---- singular resource maps to plural controller by default, we can override by provide controller name directly
                 #report
                 resource :report, only: [], controller: 'report' do
                   get 'login'

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

Commit r855:ef5cd5528b8d public

Author

r855:ef5cd5528b8d - Fri, 04 Feb 2022 15:55:30 - 11 files changed: 210 inserted, 125 deleted

Commit `r855:ef5cd5528b8d` public