cafe-grader-web Commit - r514:41d1cd2793ff

cafe-grader-web

Commit `r514:41d1cd2793ff` public

parent | child

Description:

merge

Commit status:

[Not Reviewed]

References:

merge java

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r514:41d1cd2793ff - Sun, 28 Sep 2014 04:44:55 - 11 files changed: 301 inserted, 132 deleted

app/views/application/_bar_graph.html.haml created 644 ¶ +44

@@ -0,0 +1,44
	1	+ - param = {} unless param
	2	+ - graph_height = param[:graph_height] \|\| 100
	3	+ - bar_width = param[:bar_width] \|\| 14
	4	+ - graph_width = (bar_width * histogram[:data].count) + 20
	5	+ :css
	6	+ .hist_bar {
	7	+ width: #{bar_width-1}px;
	8	+ position: absolute;
	9	+ background-color: lightblue;
	10	+ }
	11	+ .hist_fill {
	12	+ width: #{bar_width-1}px;
	13	+ position: absolute;
	14	+ background-color: #eee;
	15	+ }
	16	+ .hist_text {
	17	+ position: absolute;
	18	+ font-size:5px;
	19	+ }
	20	+
	21	+ %div{style: "position: relative; width: #{graph_width}px; height: 125px; background-color:#fff;" }
	22	+ //draw background
	23	+ - histogram[:data].each_index do \|i\|
	24	+ - height = histogram[:data][i] * graph_height / histogram[:summary][:max]
	25	+ - top = graph_height - height
	26	+ - left = graph_width - (i+1)*bar_width
	27	+ %div.hist_fill{style: "top: 0px; height: #{graph_height - height}px; left: #{left}px;" }
	28	+ // draw horizontal line
	29	+ - line = 3
	30	+ - line.times do \|i\|
	31	+ - top = graph_height - graph_height * (i+0.5)/ line
	32	+ %div{style: "position:absolute;width: #{graph_width-21}px;height: 1px;left: 20px;top:#{top}px;background-color: #333;"}
	33	+ %div.hist_text{style: "position:absolute;left: 0px;top:#{top-6}px"}
	34	+ =((i+0.5) * histogram[:summary][:max] / line).to_i
	35	+ // draw the actual bar and text
	36	+ - @histogram[:data].each_index do \|i\|
	37	+ - height = histogram[:data][i] * graph_height / histogram[:summary][:max]
	38	+ - top = graph_height - height
	39	+ - left = graph_width - (i+1)*bar_width
	40	+ %div.hist_bar{style: "top: #{top}px; height: #{height}px; left: #{left}px; dae: #{histogram[:data][i]}" }
	41	+ - if i % 7 == 1
	42	+ %div.hist_text{style: "top:#{graph_height + 5}px;left: #{left}px;"} #{(Time.zone.today - i.day).strftime('%-d')}
	43	+ - if (Time.now.in_time_zone - i.day).day == 15
	44	+ %div.hist_text{style: "top:#{graph_height + 15}px;left: #{left}px;"} #{(Time.zone.today - i.day).strftime('%b')}

app/controllers/problems_controller.rb ¶ +20 -3

                   @problem.full_score = 100
                   @problem.available = false
                   @problem.test_allowed = true
                   @problem.output_only = false
                   @problem.date_added = Time.new
                   if @problem.save
                     flash[:notice] = 'Problem was successfully created.'
                     redirect_to :action => 'list'
                   else
                     flash[:notice] = 'Error saving problem'
                     redirect_to :action => 'list'
                   end
                 end
                 def edit
                   @problem = Problem.find(params[:id])
                   @description = @problem.description
                 end
                 def update
                   @problem = Problem.find(params[:id])
                   @description = @problem.description
                   if @description == nil and params[:description][:body]!=''
                     @description = Description.new(params[:description])
                     if !@description.save
                       flash[:notice] = 'Error saving description'
                       render :action => 'edit' and return
                     end
                     @problem.description = @description
                   elsif @description!=nil
                     if !@description.update_attributes(params[:description])
                       flash[:notice] = 'Error saving description'
                       render :action => 'edit' and return
                     end
                   end
                   if params[:file] and params[:file].content_type != 'application/pdf'
                       flash[:notice] = 'Error: Uploaded file is not PDF'
                       render :action => 'edit' and return
                   end
                   if @problem.update_attributes(params[:problem])
                     flash[:notice] = 'Problem was successfully updated.'
                     unless params[:file] == nil or params[:file] == ''
                       flash[:notice] = 'Problem was successfully updated and a new PDF file is uploaded.'
                       out_dirname = "#{Problem.download_file_basedir}/#{@problem.id}"
                       if not FileTest.exists? out_dirname
                         Dir.mkdir out_dirname
                       end
                       out_filename = "#{out_dirname}/#{@problem.name}.pdf"
                       if FileTest.exists? out_filename
                         File.delete out_filename
                       end
                       File.open(out_filename,"wb") do |file|
                         file.write(params[:file].read)
                       end
                       @problem.description_filename = "#{@problem.name}.pdf"
                       @problem.save
                     end
                     redirect_to :action => 'show', :id => @problem
                   else
                     render :action => 'edit'
                   end
                 end
                 def destroy
                   Problem.find(params[:id]).destroy
                   redirect_to :action => 'list'
                 end
                 def toggle
                   @problem = Problem.find(params[:id])
                   @problem.available = !(@problem.available)
                   @problem.save
                 end
                 def turn_all_off
                   Problem.find(:all,
                                :conditions => "available = 1").each do |problem|
                     problem.available = false
                     problem.save
                   end
                   redirect_to :action => 'list'
                 end
                 def turn_all_on
                   Problem.find(:all,
                                :conditions => "available = 0").each do |problem|
                     problem.available = true
                     problem.save
                   end
                   redirect_to :action => 'list'
                 end
                 def stat
                   @problem = Problem.find(params[:id])
-            -     if !@problem.available
+            +     unless @problem.available or session[:admin]
                     redirect_to :controller => 'main', :action => 'list'
-            -     else
+            +       return
-            -       @submissions = Submission.includes(:user).where(problem_id: params[:id]).order(:user_id,:id)
                   end
+            +     @submissions = Submission.includes(:user).where(problem_id: params[:id]).order(:user_id,:id)
+            +
+            +     #stat summary
+            +     range =65
+            +     @histogram = { data: Array.new(range,0), summary: {} }
+            +     user = Hash.new(0)
+            +     @submissions.find_each do |sub|
+            +       d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
+            +       @histogram[:data][d.to_i] += 1 if d < range
+            +       user[sub.user_id] = [user[sub.user_id], (sub.points >= @problem.full_score) ? 1 : 0].max
+            +     end
+            +     @histogram[:summary][:max] = [@histogram[:data].max,1].max
+            +
+            +     @summary = { attempt: user.count, solve: 0 }
+            +     user.each_value { |v| @summary[:solve] += 1 if v == 1 }
                 end
                 def manage
                   @problems = Problem.find(:all, :order => 'date_added DESC')
                 end
                 def do_manage
                   if params.has_key? 'change_date_added'
                     change_date_added
                   elsif params.has_key? 'add_to_contest'
                     add_to_contest
                   elsif params.has_key? 'enable_problem'
                     set_available(true)
                   elsif params.has_key? 'disable_problem'
                     set_available(false)
                   end
                   redirect_to :action => 'manage'
                 end
                 def import
                   @allow_test_pair_import = allow_test_pair_import?
                 end
                 def do_import
                   old_problem = Problem.find_by_name(params[:name])
                   if !allow_test_pair_import? and params.has_key? :import_to_db
                     params.delete :import_to_db
                   end
                   @problem, import_log = Problem.create_from_import_form_params(params,
                                                                                 old_problem)
                   if !@problem.errors.empty?
                     render :action => 'import' and return
                   end
                   if old_problem!=nil
                     flash[:notice] = "The test data has been replaced for problem #{@problem.name}"
                   end
                   @log = import_log
                 end
                 def remove_contest
                   problem = Problem.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if problem!=nil and contest!=nil
                     problem.contests.delete(contest)
                   end
                   redirect_to :action => 'manage'
                 end
                 ##################################
                 protected
                 def allow_test_pair_import?
                   if defined? ALLOW_TEST_PAIR_IMPORT
                     return ALLOW_TEST_PAIR_IMPORT
                   else
                     return false
                   end
                 end
                 def change_date_added
                   problems = get_problems_from_params
                   year = params[:date_added][:year].to_i
                   month = params[:date_added][:month].to_i
                   day = params[:date_added][:day].to_i
                   date = Date.new(year,month,day)
                   problems.each do |p|
                     p.date_added = date
                     p.save
                   end
                 end
                 def add_to_contest
                   problems = get_problems_from_params
                   contest = Contest.find(params[:contest][:id])
                   if contest!=nil and contest.enabled
                     problems.each do |p|
                       p.contests << contest
                     end
                   end
                 end
                 def set_available(avail)
                   problems = get_problems_from_params
                   problems.each do |p|
                     p.available = avail
                     p.save
                   end
                 end
                 def get_problems_from_params
                   problems = []
                   params.keys.each do |k|
                     if k.index('prob-')==0
                       name, id, order = k.split('-')
                       problems << Problem.find(id)
                     end
                   end
                   problems
                 end
+            +   def get_problems_stat
+            +   end
+            +
               end

app/controllers/report_controller.rb ¶ +72 -76

                 }
                 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 = nil
                         begin
                           a = Problem.find(s.problem_id)
                         rescue
                           a = nil
                         end
                         @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
-            -     if @problem
+            +     return unless @problem
-            -       #aggregrate by language
-            -       @by_lang = {}
+            +     @by_lang = {} #aggregrate by language
-            -       Submission.where(problem_id: @problem.id).find_each do |sub|
-            -         lang = Language.find_by_id(sub.language_id)
-            -         next unless lang
-            -         next unless sub.points >= @problem.full_score
-            -         #initialize
+            +     range =65
-            -         unless @by_lang.has_key?(lang.pretty_name)
+            +     @histogram = { data: Array.new(range,0), summary: {} }
-            -           @by_lang[lang.pretty_name] = {
+            +     @summary = {count: 0, solve: 0, attempt: 0}
-            -             runtime: { avail: false, value: 2**30-1 },
+            +     user = Hash.new(0)
-            -             memory: { avail: false, value: 2**30-1 },
+            +     Submission.where(problem_id: @problem.id).find_each do |sub|
-            -             length: { avail: false, value: 2**30-1 },
+            +       #histogram
-            -             first: { avail: false, value: DateTime.new(3000,1,1) }
+            +       d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
-            -           }
+            +       @histogram[:data][d.to_i] += 1 if d < range
-            -         end
-            -         if sub.max_runtime and sub.max_runtime < @by_lang[lang.pretty_name][:runtime][:value]
+            +       @summary[:count] += 1
-            -           @by_lang[lang.pretty_name][:runtime] = {
+            +       user[sub.user_id] = [user[sub.user_id], (sub.points >= @problem.full_score) ? 1 : 0].max
-            -             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]
+            +       lang = Language.find_by_id(sub.language_id)
-            -           @by_lang[lang.pretty_name][:memory] = {
+            +       next unless lang
-            -             avail: true,
+            +       next unless sub.points >= @problem.full_score
-            -             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
+            +       #initialize
-            -            !sub.user.admin?
+            +       unless @by_lang.has_key?(lang.pretty_name)
-            -           @by_lang[lang.pretty_name][:first] = {
+            +         @by_lang[lang.pretty_name] = {
-            -             avail: true,
+            +           runtime: { avail: false, value: 2**30-1 },
-            -             user_id: sub.user_id,
+            +           memory: { avail: false, value: 2**30-1 },
-            -             value: sub.submitted_at,
+            +           length: { avail: false, value: 2**30-1 },
-            -             sub_id: sub.id
+            +           first: { avail: false, value: DateTime.new(3000,1,1) }
-            -           }
+            +         }
-            -         end
+            +       end
-            -         if @by_lang[lang.pretty_name][:length][:value] > sub.effective_code_length
+            +       if sub.max_runtime and sub.max_runtime < @by_lang[lang.pretty_name][:runtime][:value]
-            -           @by_lang[lang.pretty_name][:length] = {
+            +         @by_lang[lang.pretty_name][:runtime] = { avail: true, user_id: sub.user_id, value: sub.max_runtime, sub_id: sub.id }
-            -             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 sub.peak_memory and sub.peak_memory < @by_lang[lang.pretty_name][:memory][:value]
-            -       if @by_lang and @by_lang.first
+            +         @by_lang[lang.pretty_name][:memory] = { avail: true, user_id: sub.user_id, value: sub.peak_memory, sub_id: sub.id }
-            -         @best = @by_lang.first[1].clone
+            +       end
-            -         @by_lang.each do |lang,prop|
-            -           if @best[:runtime][:value] >= prop[:runtime][:value]
+            +       if sub.submitted_at and sub.submitted_at < @by_lang[lang.pretty_name][:first][:value] and
-            -             @best[:runtime] = prop[:runtime]
+            +           !sub.user.admin?
-            -             @best[:runtime][:lang] = lang
+            +         @by_lang[lang.pretty_name][:first] = { avail: true, user_id: sub.user_id, value: sub.submitted_at, sub_id: sub.id }
-            -           end
+            +       end
-            -           if @best[:memory][:value] >= prop[:memory][:value]
-            -             @best[:memory] = prop[:memory]
+            +       if @by_lang[lang.pretty_name][:length][:value] > sub.effective_code_length
-            -             @best[:memory][:lang] = lang
+            +         @by_lang[lang.pretty_name][:length] = { avail: true, user_id: sub.user_id, value: sub.effective_code_length, sub_id: sub.id }
-            -           end
+            +       end
-            -           if @best[:length][:value] >= prop[:length][:value]
+            +     end
-            -             @best[:length] = prop[:length]
-            -             @best[:length][:lang] = lang
+            +     #process user_id
-            -           end
+            +     @by_lang.each do |lang,prop|
-            -           if @best[:first][:value] >= prop[:first][:value]
+            +       prop.each do |k,v|
-            -             @best[:first] = prop[:first]
+            +         v[:user] = User.exists?(v[:user_id]) ? User.find(v[:user_id]).full_name : "(NULL)"
-            -             @best[:first][:lang] = lang
+            +       end
-            -           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
+            +
               end

app/controllers/users_controller.rb ¶ +19 -1

                 verify :method => :post, :only => [:chg_passwd],
                        :redirect_to => { :action => :index }
                 #in_place_edit_for :user, :alias_for_editing
                 #in_place_edit_for :user, :email_for_editing
                 def index
                   if !GraderConfiguration['system.user_setting_enabled']
                     redirect_to :controller => 'main', :action => 'list'
                   else
                     @user = User.find(session[:user_id])
                   end
                 end
                 def chg_passwd
                   user = User.find(session[:user_id])
                   user.password = params[:passwd]
                   user.password_confirmation = params[:passwd_verify]
                   if user.save
                     flash[:notice] = 'password changed'
                   else
                     flash[:notice] = 'Error: password changing failed'
                   end
                   redirect_to :action => 'index'
                 end
                 def new
                   @user = User.new
                   render :action => 'new', :layout => 'empty'
                 end
                 def register
                   if(params[:cancel])
                     redirect_to :controller => 'main', :action => 'login'
                     return
                   end
                   @user = User.new(params[:user])
                   @user.password_confirmation = @user.password = User.random_password
                   @user.activated = false
                   if (@user.valid?) and (@user.save)
                     if send_confirmation_email(@user)
                       render :action => 'new_splash', :layout => 'empty'
                     else
                       @admin_email = GraderConfiguration['system.admin_email']
                       render :action => 'email_error', :layout => 'empty'
                     end
                   else
                     @user.errors.add_to_base("Email cannot be blank") if @user.email==''
                     render :action => 'new', :layout => 'empty'
                   end
                 end
                 def confirm
                   login = params[:login]
                   key = params[:activation]
                   @user = User.find_by_login(login)
                   if (@user) and (@user.verify_activation_key(key))
                     if @user.valid?  # check uniquenss of email
                       @user.activated = true
                       @user.save
                       @result = :successful
                     else
                       @result = :email_used
                     end
                   else
                     @result = :failed
                   end
                   render :action => 'confirm', :layout => 'empty'
                 end
                 def forget
                   render :action => 'forget', :layout => 'empty'
                 end
                 def retrieve_password
                   email = params[:email]
                   user = User.find_by_email(email)
                   if user
                     last_updated_time = user.updated_at || user.created_at || (Time.now.gmtime - 1.hour)
                     if last_updated_time > Time.now.gmtime - 5.minutes
                       flash[:notice] = 'The account has recently created or new password has recently been requested.  Please wait for 5 minutes'
                     else
                       user.password = user.password_confirmation = User.random_password
                       user.save
                       send_new_password_email(user)
                       flash[:notice] = 'New password has been mailed to you.'
                     end
                   else
                     flash[:notice] = I18n.t 'registration.password_retrieval.no_email'
                   end
                   redirect_to :action => 'forget'
                 end
                 def profile
                   @user = User.find(params[:id])
-            -     @submission = Submission.where(user_id: params[:id]).all
+            +     @submission = Submission.includes(:problem).where(user_id: params[:id])
+            +
+            +     range = 120
+            +     @histogram = { data: Array.new(range,0), summary: {} }
+            +     @summary = {count: 0, solve: 0, attempt: 0}
+            +     problem = Hash.new(0)
+            +
+            +     @submission.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
+            +
+            +       @summary[:count] += 1
+            +       problem[sub.problem] = [problem[sub.problem], (sub.points >= sub.problem.full_score) ? 1 : 0].max
+            +     end
+            +
+            +     @histogram[:summary][:max] = [@histogram[:data].max,1].max
+            +     @summary[:attempt] = problem.count
+            +     problem.each_value { |v| @summary[:solve] += 1 if v == 1 }
                 end
                 protected
                 def verify_online_registration
                   if !GraderConfiguration['system.online_registration']
                     redirect_to :controller => 'main', :action => 'login'
                   end
                 end
                 def send_confirmation_email(user)
                   contest_name = GraderConfiguration['contest.name']
                   activation_url = url_for(:action => 'confirm',
                                            :login => user.login,
                                            :activation => user.activation_key)
                   home_url = url_for(:controller => 'main', :action => 'index')
                   mail_subject = "[#{contest_name}] Confirmation"
                   mail_body = t('registration.email_body', {
                                   :full_name => user.full_name,
                                   :contest_name => contest_name,
                                   :login => user.login,
                                   :password => user.password,
                                   :activation_url => activation_url,
                                   :admin_email => admin_email
                                 })
                   logger.info mail_body
                   send_mail(user.email, mail_subject, mail_body)
                 end
                 def send_new_password_email(user)
                   contest_name = GraderConfiguration['contest.name']
                   mail_subject = "[#{contest_name}] Password recovery"
                   mail_body = t('registration.password_retrieval.email_body', {
                                   :full_name => user.full_name,
                                   :contest_name => contest_name,
                                   :login => user.login,
                                   :password => user.password,
                                   :admin_email => admin_email
                                 })
                   logger.info mail_body
                   send_mail(user.email, mail_subject, mail_body)
                 end
                 # allow viewing of regular user profile only when options allow so
                 # only admins can view admins profile
                 def profile_authorization
                   #if view admins' profile, allow only admin
                   return false unless(params[:id])
                   user = User.find(params[:id])
                   return false unless user
                   return admin_authorization if user.admin?
                   return true if GraderConfiguration["right.user_view_submission"]
                   #finally, we allow only admin
                   admin_authorization
                 end
               end

app/models/problem.rb ¶ +7

               class Problem < ActiveRecord::Base
                 belongs_to :description
                 has_and_belongs_to_many :contests, :uniq => true
                 has_many :test_pairs, :dependent => :delete_all
                 validates_presence_of :name
                 validates_format_of :name, :with => /^\w+$/
                 validates_presence_of :full_name
                 scope :available, :conditions => {:available => true}
                 DEFAULT_TIME_LIMIT = 1
                 DEFAULT_MEMORY_LIMIT = 32
                 def self.find_available_problems
                   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_to_base('Import error.')
                   end
                   return problem, importer.log_msg
                 end
                 def self.download_file_basedir
                   return "#{Rails.root}/data/tasks"
                 end
+            +
+            +   def get_submission_stat
+            +     result = Hash.new
+            +     #total number of submission
+            +     result[:total_sub] = Submission.where(problem_id: self.id).count
+            +     result[:attempted_user] = Submission.where(problem_id: self.id).group_by(:user_id)
+            +   end
                 protected
                 def self.to_i_or_default(st, default)
                   if st!=''
                     result = st.to_i
                   end
                   result ||= default
                 end
                 def self.to_f_or_default(st, default)
                   if st!=''
                     result = st.to_f
                   end
                   result ||= default
                 end
                 def self.extract_params_and_check(params, problem)
                   time_limit = Problem.to_f_or_default(params[:time_limit],
                                                        DEFAULT_TIME_LIMIT)
                   memory_limit = Problem.to_i_or_default(params[:memory_limit],
                                                          DEFAULT_MEMORY_LIMIT)
                   if time_limit<=0 or time_limit >60
                     problem.errors.add_to_base('Time limit out of range.')
                   end
                   if memory_limit==0 and params[:memory_limit]!='0'
                     problem.errors.add_to_base('Memory limit format errors.')
                   elsif memory_limit<=0 or memory_limit >512
                     problem.errors.add_to_base('Memory limit out of range.')
                   end
                   if params[:file]==nil or params[:file]==''
                     problem.errors.add_to_base('No testdata file.')
                   end
                   checker_name = 'text'
                   if ['text','float'].include? params[:checker]
                     checker_name = params[:checker]
                   end
                   file = params[:file]
                   if !problem.errors.empty?
                     return nil, problem
                   end
                   problem.name = params[:name]
                   if params[:full_name]!=''
                     problem.full_name = params[:full_name]
                   else
                     problem.full_name = params[:name]
                   end
                   return [{
                             :time_limit => time_limit,
                             :memory_limit => memory_limit,
                             :file => file,
                             :checker_name => checker_name
                           },
                           problem]
                 end
               end

app/views/graders/submission.html.haml ¶ +8 -2

               %style{type: "text/css"}
                 = @css_style
               :css
                 .field {
                   font-weight: bold;
                   text-align: right;
                   padding: 3px;
                 }
               %h1= "Submission: #{@submission.id}"
               %h2 Stat
               %table.info
                 %thead
                   %tr.info-head
                     %th Field
                     %th Value
                 %tbody
                   %tr{class: cycle('info-even','info-odd')}
                     %td.field User:
-            -       %td.value= "(#{@submission.user.login}) #{@submission.user.full_name}"
+            +       %td.value
+            +         - if @submission.user
+            +           = link_to "(#{@submission.user.login})", controller: "users", action: "profile", id: @submission.user
+            +           = @submission.user.full_name
+            +         - else
+            +           = "(n/a)"
                   %tr{class: cycle('info-even','info-odd')}
                     %td.field Problem:
                     %td.value
                       - if @submission.problem!=nil
-            -           = "(#{@submission.problem.name}) #{@submission.problem.full_name}"
+            +           = link_to "(#{@submission.problem.name})", controller: "problems", action: "stat", id: @submission.problem
+            +           = @submission.problem.full_name
                       - else
                         = "(n/a)"
                   %tr{class: cycle('info-even','info-odd')}
                     %td.field Tries:
                     %td.value= @submission.number
                   %tr{class: cycle('info-even','info-odd')}
                     %td.field Submitted:
                     %td.value #{time_ago_in_words(@submission.submitted_at)} ago (at #{@submission.submitted_at.to_formatted_s(:long)})
                   %tr{class: cycle('info-even','info-odd')}
                     %td.field Graded:
                     %td.value #{time_ago_in_words(@submission.graded_at)} ago (at #{@submission.graded_at.to_formatted_s(:long)})
                   %tr{class: cycle('info-even','info-odd')}
                     %td.field Points:
                     %td.value #{@submission.points}/#{@submission.problem.full_score}
                   %tr{class: cycle('info-even','info-odd')}
                     %td.field Comment:
                     %td.value #{@submission.grader_comment}
                   %tr{class: cycle('info-even','info-odd')}
                     %td.field Runtime (s):
                     %td.value #{@submission.max_runtime}
                   %tr{class: cycle('info-even','info-odd')}
                     %td.field Memory (kb):
                     %td.value #{@submission.peak_memory}
                   - if session[:admin]
                     %tr{class: cycle('info-even','info-odd')}
                       %td.field IP:
                       %td.value #{@submission.ip_address}
               %h2 Source code
               //%div.highlight{:style => "border: 1px solid black;"}
               =@formatted_code.html_safe

app/views/problems/stat.html.haml ¶ +17

               :css
                 .fix-width {
                   font-family: "Consolas, Monaco, Droid Sans Mono,Mono, Monospace,Courier"
                 }
               %h1 Problem stat: #{@problem.name}
               %h2 Overview
+            +
+            + %table.info
+            +   %thead
+            +     %tr.info-head
+            +       %th Stat
+            +       %th Value
+            +   %tbody
+            +     %tr{class: cycle('info-even','info-odd')}
+            +       %td Submissions
+            +       %td= @submissions.count
+            +     %tr{class: cycle('info-even','info-odd')}
+            +       %td Solved/Attempted User
+            +       %td #{@summary[:solve]}/#{@summary[:attempt]} (#{(@summary[:solve]*100.0/@summary[:attempt]).round(1)}%)
+            +
+            + %h2 Submissions Count
+            + = render partial: 'application/bar_graph', locals: { histogram: @histogram }
+            +
               %h2 Submissions
               - if @submissions and @submissions.count > 0
                 %table.info#main_table
                   %thead
                     %tr.info-head
                       %th ID
                       %th Login
                       %th Name
                       %th Submitted_at
                       %th Points
                       %th comment
                   %tbody
                     - row_odd,curr = true,''
                     - @submissions.each do |sub|
                       - next unless sub.user
                       - row_odd,curr = !row_odd, sub.user if curr != sub.user
                       %tr{class: row_odd ? "info-odd" : "info-even"}
                         %td= link_to sub.id, controller: 'graders', action: 'submission', id: sub.id
                         %td= link_to sub.user.login, controller: :users, action: :profile, id: sub.user.id
                         %td= sub.user.full_name
                         %td= time_ago_in_words(sub.submitted_at) + " ago"
                         %td= sub.points
                         %td.fix-width= sub.grader_comment
               - else
                 No submission

app/views/report/_task_hof.html.haml ¶ +89 -40

@@ -1,79 +1,128
		1	+ - content_for :header do
		2	+ = javascript_include_tag 'local_jquery'
		3	+
		4	+ :javascript
		5	+ $(document).ready( function() {
		6	+ $("#mem_remark").hover( function() {
		7	+ $("#mem_remark_box").show();
		8	+ }, function() {
		9	+ $("#mem_remark_box").hide();
		10	+ });
		11	+ });
		12	+ alert("hahaha");
1	:css	13	:css
2	.hof_user { color: orangered; font-style: italic; }	14	.hof_user { color: orangered; font-style: italic; }
3	.hof_language { color: green; font-style: italic; }	15	.hof_language { color: green; font-style: italic; }
4	.hof_value { color: deeppink;font-style: italic; }	16	.hof_value { color: deeppink;font-style: italic; }
		17	+ .info_param { font-weight: bold;text-align: right; }
		18	+ .tooltip {
		19	+ font-family: Verdana,sans-serif;
		20	+ font-weight: normal;
		21	+ text-align: left;
		22	+ font-size: 1.0em;
		23	+ color: black;
		24	+ line-height: 1.1;
		25	+ display: none;
		26	+ min-width: 20em;
		27	+ position: absolute;
		28	+ left: 25px;
		29	+ bottom: 5px;
		30	+ border: 1px solid;
		31	+ padding: 5px;
		32	+ background-color: #FFF;
		33	+ word-wrap: break-word;
		34	+ z-index: 9999;
		35	+ overflow: auto;
		36	+ }
5		37
6	- %h2 ~~Overall of~~ #{Problem.find(params[:id]).full_name}	38	+ %h1 (#{Problem.find(params[:id]).name}) #{Problem.find(params[:id]).full_name}
		39	+
		40	+ %h2 Problem Stat
		41	+ %table.info
		42	+ %thead
		43	+ %tr.info-head
		44	+ %th Stat
		45	+ %th Value
		46	+ %tbody
		47	+ %tr{class: cycle('info-even','info-odd')}
		48	+ %td.info_param Submissions
		49	+ %td= @summary[:count]
		50	+ %tr{class: cycle('info-even','info-odd')}
		51	+ %td.info_param Solved/Attempted User
		52	+ %td #{@summary[:solve]}/#{@summary[:attempt]} (#{(@summary[:solve]*100.0/@summary[:attempt]).round(1)}%)
		53	+ - if @best
		54	+ %tr{class: cycle('info-even','info-odd')}
		55	+ %td.info_param Best Runtime
		56	+ %td
		57	+ by #{link_to @best[:runtime][:user], controller:'users', action:'profile', id:@best[:memory][:user_id]}
		58	+ using <span class="hof_language">#{@best[:runtime][:lang]}</span>
		59	+ with <span class="hof_value">#{@best[:runtime][:value] * 1000} milliseconds</span>
		60	+ at submission
		61	+ = link_to("#" + @best[:runtime][:sub_id].to_s, controller: 'graders', action: 'submission', id:@best[:runtime][:sub_id])
		62	+
		63	+ %tr{class: cycle('info-even','info-odd')}
		64	+ %td.info_param
		65	+ Best Memory Usage
		66	+ %sup{ id: "mem_remark", style: "position:relative; color: blue;"}
		67	+ [?]
		68	+ %span.tooltip#mem_remark_box
		69	+ This counts only for submission with 100% score.
		70	+ Right now, java is excluded from memory usage competition. (Because it always uses 2GB memory...)
		71	+ %td
		72	+ by #{link_to @best[:memory][:user], controller:'users', action:'profile', id:@best[:memory][:user_id]}
		73	+ using <span class="hof_language">#{@best[:memory][:lang]}</span>
		74	+ with <span class="hof_value">#{number_with_delimiter(@best[:memory][:value])} kbytes </span>
		75	+ at submission
		76	+ = link_to("#" + @best[:memory][:sub_id].to_s, controller: 'graders' , action: 'submission', id:@best[:memory][:sub_id])
		77	+
		78	+ %tr{class: cycle('info-even','info-odd')}
		79	+ %td.info_param Shortest Code
		80	+ %td
		81	+ by #{link_to @best[:length][:user], controller:'users', action:'profile', id:@best[:length][:user_id]}
		82	+ using <span class="hof_language">#{@best[:length][:lang]}</span>
		83	+ with <span class="hof_value">#{@best[:length][:value]} bytes</span>
		84	+ at submission
		85	+ = link_to("#" + @best[:length][:sub_id].to_s, controller: 'graders' , action: 'submission', id: @best[:length][:sub_id])
		86	+
		87	+ %tr{class: cycle('info-even','info-odd')}
		88	+ %td.info_param First solver
		89	+ %td
		90	+ #{link_to @best[:first][:user], controller:'users', action:'profile', id:@best[:first][:user_id]} is the first solver
		91	+ using <span class="hof_language">#{@best[:first][:lang]}</span>
		92	+ on <span class="hof_value">#{@best[:first][:value]}</span>
		93	+ at submission
		94	+ = link_to("#" + @best[:first][:sub_id].to_s, controller: 'graders' , action: 'submission', id: @best[:first][:sub_id])
7		95
8	- if @best	96	- if @best
9	- %b Best Runtime:
10	- by #{link_to @best[:runtime][:user], controller:'users', action:'profile', id:@best[:memory][:user_id]}
11	- using <span class="hof_language">#{@best[:runtime][:lang]}</span>
12	- with <span class="hof_value">#{@best[:runtime][:value] * 1000} milliseconds</span>
13	- at submission
14	- = link_to("#" + @best[:runtime][:sub_id].to_s, controller: 'graders', action: 'submission', id:@best[:runtime][:sub_id])
15	- %br/
16	-
17	- %b Best Memory Usage:
18	- by #{link_to @best[:memory][:user], controller:'users', action:'profile', id:@best[:memory][:user_id]}
19	- using <span class="hof_language">#{@best[:memory][:lang]}</span>
20	- with <span class="hof_value">#{number_with_delimiter(@best[:memory][:value])} kbytes </span>
21	- at submission
22	- = link_to("#" + @best[:memory][:sub_id].to_s, controller: 'graders' , action: 'submission', id:@best[:memory][:sub_id])
23	- %br/
24	-
25	- %b Shortest Code:
26	- by #{link_to @best[:length][:user], controller:'users', action:'profile', id:@best[:length][:user_id]}
27	- using <span class="hof_language">#{@best[:length][:lang]}</span>
28	- with <span class="hof_value">#{@best[:length][:value]} bytes</span>
29	- at submission
30	- = link_to("#" + @best[:length][:sub_id].to_s, controller: 'graders' , action: 'submission', id: @best[:length][:sub_id])
31	- %br/
32	-
33	- %b First solver:
34	- #{link_to @best[:first][:user], controller:'users', action:'profile', id:@best[:first][:user_id]} is the first solver
35	- using <span class="hof_language">#{@best[:first][:lang]}</span>
36	- on <span class="hof_value">#{@best[:first][:value]}</span>
37	- at submission
38	- = link_to("#" + @best[:first][:sub_id].to_s, controller: 'graders' , action: 'submission', id: @best[:first][:sub_id])
39	- %br/
40	-
41	-
42	- %p
43	- This counts only for submission with 100% score <br/>
44	- Right now, java is excluded from memory usage competition. (Because it always uses 2GB memory...)
45	-
46	%h2 By language	97	%h2 By language
47		98
48	%table.info	99	%table.info
49	%thead	100	%thead
50	%tr.info-head	101	%tr.info-head
51	%th Language	102	%th Language
52	%th Best runtime (ms)	103	%th Best runtime (ms)
53	%th Best memory (kbytes)	104	%th Best memory (kbytes)
54	%th Shortest Code (bytes)	105	%th Shortest Code (bytes)
55	%th First solver	106	%th First solver
56	%tbody	107	%tbody
57	- @by_lang.each do \|lang,value\|	108	- @by_lang.each do \|lang,value\|
58	%tr{class: cycle('info-even','info-odd')}	109	%tr{class: cycle('info-even','info-odd')}
59	%td= lang	110	%td= lang
60	%td	111	%td
61	= link_to value[:runtime][:user], controller: 'users', action: 'profile', id: value[:runtime][:user_id]	112	= link_to value[:runtime][:user], controller: 'users', action: 'profile', id: value[:runtime][:user_id]
62	= "(#{(value[:runtime][:value] * 1000).to_i} @"	113	= "(#{(value[:runtime][:value] * 1000).to_i} @"
63	= "#{link_to("#" + value[:runtime][:sub_id].to_s, controller: 'graders' , action: 'submission', id: value[:runtime][:sub_id])} )".html_safe	114	= "#{link_to("#" + value[:runtime][:sub_id].to_s, controller: 'graders' , action: 'submission', id: value[:runtime][:sub_id])} )".html_safe
64	%td	115	%td
65	= link_to value[:memory][:user], controller: 'users', action: 'profile', id: value[:memory][:user_id]	116	= link_to value[:memory][:user], controller: 'users', action: 'profile', id: value[:memory][:user_id]
66	= "(#{number_with_delimiter(value[:memory][:value])} @"	117	= "(#{number_with_delimiter(value[:memory][:value])} @"
67	= "#{link_to("#" + value[:memory][:sub_id].to_s, controller: 'graders' , action: 'submission', id: value[:memory][:sub_id])} )".html_safe	118	= "#{link_to("#" + value[:memory][:sub_id].to_s, controller: 'graders' , action: 'submission', id: value[:memory][:sub_id])} )".html_safe
68	%td	119	%td
69	= link_to value[:length][:user], controller: 'users', action: 'profile', id: value[:length][:user_id]	120	= link_to value[:length][:user], controller: 'users', action: 'profile', id: value[:length][:user_id]
70	= "(#{value[:length][:value]} @"	121	= "(#{value[:length][:value]} @"
71	= "#{link_to("#" + value[:length][:sub_id].to_s, controller: 'graders' , action: 'submission', id: value[:length][:sub_id])} )".html_safe	122	= "#{link_to("#" + value[:length][:sub_id].to_s, controller: 'graders' , action: 'submission', id: value[:length][:sub_id])} )".html_safe
72	%td	123	%td
73	- if value[:first][:user] != '(NULL)' #TODO: i know... this is wrong...	124	- if value[:first][:user] != '(NULL)' #TODO: i know... this is wrong...
74	= link_to value[:first][:user], controller: 'users', action: 'profile', id: value[:first][:user_id]	125	= link_to value[:first][:user], controller: 'users', action: 'profile', id: value[:first][:user_id]
75	= "(#{value[:first][:value]} @"	126	= "(#{value[:first][:value]} @"
76	= "#{link_to("#" + value[:first][:sub_id].to_s, controller: 'graders' , action: 'submission', id: value[:first][:sub_id])} )".html_safe	127	= "#{link_to("#" + value[:first][:sub_id].to_s, controller: 'graders' , action: 'submission', id: value[:first][:sub_id])} )".html_safe
77		128
78	- - else
79	- %h3 No submissions

app/views/report/problem_hof.html.haml ¶ +3 -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
-            - %h1 Tasks Hall of Fame
+            + %h1 Hall of Fame
               .task-menu
                 Tasks
                 %br/
                 - @problems.each do |prob|
                   = link_to( "[#{prob.name}]", {id: prob.id})
               - unless params[:id]
                 /=render partial: 'all_time_hof'
                 Please select a problem.
               - else
                 =render partial: 'task_hof'
+            +   %h2 Submission History
+            +   =render partial: 'application/bar_graph', locals: { histogram: @histogram }

app/views/users/profile.html.haml ¶ +20 -6

               - content_for :header do
                 = javascript_include_tag 'local_jquery'
-            - %script{:type=>"text/javascript"}
+            + :javascript
                 $(function () {
-            -   $('#submission_table').tablesorter({widgets: ['zebra']});
+            +     $('#submission_table').tablesorter({widgets: ['zebra']});
                 });
               :css
                 .fix-width {
                   font-family: Droid Sans Mono,Consolas, monospace, mono, Courier New, Courier;
                 }
-            - %h1= @user.full_name + ' Profile'
+            + %h1= @user.full_name
-            - %h2 Basic info
               <b>Login:</b> #{@user.login} <br/>
               <b>Full name:</b> #{@user.full_name} <br />
               %h2 Problem Stat
+            + %table.info
+            +   %thead
+            +     %tr.info-head
+            +       %th Stat
+            +       %th Value
+            +   %tbody
+            +     %tr{class: cycle('info-even','info-odd')}
+            +       %td.info_param Submissions
+            +       %td= @summary[:count]
+            +     %tr{class: cycle('info-even','info-odd')}
+            +       %td.info_param Solved/Attempted Problem
+            +       %td #{@summary[:solve]}/#{@summary[:attempt]} (#{(@summary[:solve]*100.0/@summary[:attempt]).round(1)}%)
-            - %h2 Submissions
+            + %h2 Submission History
+            +
+            + =render partial: 'application/bar_graph', locals: {histogram: @histogram, param: {bar_width: 7}}
+            +
               %table.tablesorter-cafe#submission_table
                 %thead
                   %tr
                     %th ID
                     %th Problem code
                     %th Problem full name
                     %th Language
                     %th Submitted at
                     %th Result
                     %th Score
                     - if session[:admin]
                       %th IP
                 %tbody
                   - @submission.each do |s|
                     - next unless s.problem
                     %tr
                       %td= link_to "#{s.id}", controller: "graders", action: "submission", id: s.id
-            -         %td= s.problem.name
+            +         %td= link_to s.problem.name, controller: "problems", action: "stat", id: s.problem
                       %td= s.problem.full_name
                       %td= s.language.pretty_name
                       %td  #{s.submitted_at.strftime('%Y-%m-%d %H:%M')} (#{time_ago_in_words(s.submitted_at)} ago)
                       %td.fix-width= s.grader_comment
                       %td= (s.points*100)/s.problem.full_score
                       - if session[:admin]
                         %td= s.ip_address

lib/grader_script.rb ¶ +2 -2

               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 &"
+            +     GraderScript.call_grader "#{env} queue --err-log &"
-            -     GraderScript.call_grader "#{env} test_request &"
+            +     GraderScript.call_grader "#{env} test_request -err-log &"
                 end
                 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
               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

r514:41d1cd2793ff - Sun, 28 Sep 2014 04:44:55 - 11 files changed: 301 inserted, 132 deleted

Sign in to your account

Commit r514:41d1cd2793ff public

Author

r514:41d1cd2793ff - Sun, 28 Sep 2014 04:44:55 - 11 files changed: 301 inserted, 132 deleted

Commit `r514:41d1cd2793ff` public