cafe-grader-web Commit - r880:31e27f513ce9

cafe-grader-web

Commit `r880:31e27f513ce9` public

parent | child

Description:

wip

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r880:31e27f513ce9 - Fri, 07 Oct 2022 04:48:27 - 9 files changed: 173 inserted, 142 deleted

app/controllers/problems_controller.rb ¶ +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: :index
                   else
                     flash[:notice] = 'Error saving problem'
                   redirect_to action: :index
                   end
                 end
                 def edit
                   @description = @problem.description
                 end
                 def update
                   if problem_params[:statement] && problem_params[:statement].content_type != 'application/pdf'
                       flash[:error] = 'Error: Uploaded file is not PDF'
                       render :action => 'edit'
                       return
                   end
                   if @problem.update(problem_params)
                     flash[:notice] = 'Problem was successfully updated. '
                     flash[:notice] += 'A new statement PDF is uploaded' if problem_params[:statement]
                     @problem.save
                     redirect_to edit_problem_path(@problem)
                   else
                     render :action => 'edit'
                   end
                 end
                 def destroy
                   @problem.destroy
                   redirect_to action: :index
                 end
                 def toggle
                   @problem.update(available: !(@problem.available) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def toggle_test
                   @problem.update(test_allowed: !(@problem.test_allowed?) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def toggle_view_testcase
                   @problem.update(view_testcase: !(@problem.view_testcase?) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def turn_all_off
                   Problem.available.all.each do |problem|
                     problem.available = false
                     problem.save
                   end
                   redirect_to action: :index
                 end
                 def turn_all_on
                   Problem.where.not(available: true).each do |problem|
                     problem.available = true
                     problem.save
                   end
                   redirect_to action: :index
                 end
                 def stat
                   unless @problem.available or session[:admin]
                     redirect_to :controller => 'main', :action => 'list'
                     return
                   end
                   @submissions = Submission.includes(:user).includes(:language).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.try(:points) || 0) >= @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 }
+            +
+            +     #for new graph
+            +     @chart_dataset = @problem.get_jschart_history.to_json.html_safe
                 end
                 def manage
                   @problems = Problem.order(date_added: :desc)
                 end
                 def do_manage
                   if params.has_key? 'change_date_added' and params[:date_added].strip.empty? == false
                     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)
                   elsif params.has_key? 'add_group'
                     group = Group.find(params[:group_id])
                     ok = []
                     failed = []
                     get_problems_from_params.each do |p|
                       begin
                         group.problems << p
                         ok << p.full_name
                       rescue => e
                         failed << p.full_name
                       end
                     end
                     flash[:success] = "The following problems are added to the group #{group.name}: " + ok.join(', ') if ok.count > 0
                     flash[:alert] = "The following problems are already in the group #{group.name}: " + failed.join(', ') if failed.count > 0
                   elsif params.has_key? 'add_tags'
                     get_problems_from_params.each do |p|
                       p.tag_ids += params[:tag_ids]
                     end
                   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
                   date = Date.parse(params[:date_added])
                   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

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

                                  ip: x
                                }
                   end
                 end
                 def login_detail_query
                   @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 = Time.zone.now
                   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
                   @logins = Login.includes(:user).where("logins.created_at >= ? AND logins.created_at <= ?",@since_time, @until_time)
                   case params[:users]
                   when 'enabled'
                     @logins = @logins.where(users: {enabled: true})
                   when 'group'
                     @logins = @logins.joins(user: :groups).where(user: {groups: {id: params[:groups]}}) if params[:groups]
                   end
                 end
                 def submission
                 end
                 def submission_query
                   @submissions = Submission
                     .includes(:problem).includes(:user).includes(:language)
                   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: {} }
                   @summary = {count: 0, solve: 0, attempt: 0}
                   user = Hash.new(0)
-            -     Submission.where(problem_id: @problem.id).find_each do |sub|
+            +     Submission.where(problem_id: @problem.id).includes(:language).each do |sub|
                     #histogram
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     #@histogram[:data][d.to_i] += 1 if d < range
                     next unless sub.points
                     @summary[:count] += 1
                     user[sub.user_id] = [user[sub.user_id], (sub.points >= @problem.full_score) ? 1 : 0].max
-            -       lang = Language.find_by_id(sub.language_id)
+            +       #lang = Language.find_by_id(sub.language_id)
+            +       lang = sub.language
                     next unless lang
                     next unless sub.points >= @problem.full_score
                     #initialize
                     unless @by_lang.has_key?(lang.pretty_name)
                       @by_lang[lang.pretty_name] = {
                         runtime: { avail: false, value: 2**30-1 },
                         memory: { avail: false, value: 2**30-1 },
                         length: { avail: false, value: 2**30-1 },
                         first: { avail: false, value: DateTime.new(3000,1,1) }
                       }
                     end
                     if sub.max_runtime and sub.max_runtime < @by_lang[lang.pretty_name][:runtime][:value]
                       @by_lang[lang.pretty_name][:runtime] = { avail: true, user_id: sub.user_id, value: sub.max_runtime, sub_id: sub.id }
                     end
                     if sub.peak_memory and sub.peak_memory < @by_lang[lang.pretty_name][:memory][:value]
                       @by_lang[lang.pretty_name][:memory] = { avail: true, user_id: sub.user_id, value: sub.peak_memory, sub_id: sub.id }
                     end
                     if sub.submitted_at and sub.submitted_at < @by_lang[lang.pretty_name][:first][:value] and sub.user and
                         !sub.user.admin?
                       @by_lang[lang.pretty_name][:first] = { avail: true, user_id: sub.user_id, value: sub.submitted_at, sub_id: sub.id }
                     end
                     if @by_lang[lang.pretty_name][:length][:value] > sub.effective_code_length
                       @by_lang[lang.pretty_name][:length] = { avail: true, user_id: sub.user_id, value: sub.effective_code_length, sub_id: sub.id }
                     end
                   end
                   #process user_id
                   @by_lang.each do |lang,prop|
                     prop.each do |k,v|
                       v[:user] = User.exists?(v[:user_id]) ? User.find(v[:user_id]).full_name : "(NULL)"
                     end
                   end
                   #sum into best
                   if @by_lang and @by_lang.first
                     @best = @by_lang.first[1].clone
                     @by_lang.each do |lang,prop|
                       if @best[:runtime][:value] >= prop[:runtime][:value]
                         @best[:runtime] = prop[:runtime]
                         @best[:runtime][:lang] = lang
                       end
                       if @best[:memory][:value] >= prop[:memory][:value]
                         @best[:memory] = prop[:memory]
                         @best[:memory][:lang] = lang
                       end
                       if @best[:length][:value] >= prop[:length][:value]
                         @best[:length] = prop[:length]
                         @best[:length][:lang] = lang
                       end
                       if @best[:first][:value] >= prop[:first][:value]
                         @best[:first] = prop[:first]
                         @best[:first][:lang] = lang
                       end
                     end
                   end
                   #@histogram[:summary][:max] = [@histogram[:data].max,1].max
                   @summary[:attempt] = user.count
                   user.each_value { |v| @summary[:solve] += 1 if v == 1 }
                   #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

app/controllers/users_controller.rb ¶ +2 -8

                     @user = current_user;
                   end
                 end
                 def chg_passwd
                   user = User.find(session[:user_id])
                   user.password = params[:password]
                   user.password_confirmation = params[:password_confirmation]
                   if user.save
                     flash[:notice] = 'password changed'
                   else
                     flash[:notice] = 'Error: password changing failed'
                   end
                   redirect_to :action => 'profile'
                 end
                 def chg_default_language
                   user = User.find(session[:user_id])
                   user.default_language = params[:default_language]
                   if user.save
                     flash[:notice] = 'default language changed'
                   else
                     flash[:notice] = 'Error: default language changing failed'
                   end
                   redirect_to :action => 'profile'
                 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(user_params)
                   @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(: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 stat
                   @user = User.find(params[:id])
-            -     @submission = Submission.joins(:problem).where(user_id: params[:id])
+            +     @submission = Submission.joins(:problem).includes(:problem).includes(:language).where(user_id: params[:id])
                   @submission = @submission.where('problems.available = true') unless current_user.admin?
-            -     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
                     next unless sub.problem
                     problem[sub.problem] = [problem[sub.problem], ( (sub.try(:points) || 0) >= 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 }
+            +     @chart_dataset = @user.get_jschart_user_sub_history.to_json.html_safe
                 end
                 def toggle_activate
                   @user = User.find(params[:id])
                   @user.update_attributes( activated:  !@user.activated? )
                   respond_to do |format|
                     format.js { render partial: 'toggle_button',
                                 locals: {button_id: "#toggle_activate_user_#{@user.id}",button_on: @user.activated? } }
                   end
                 end
                 def toggle_enable
                   @user = User.find(params[:id])
                   @user.update_attributes( enabled:  !@user.enabled? )
                   respond_to do |format|
                     format.js { render partial: 'toggle_button',
                                 locals: {button_id: "#toggle_enable_user_#{@user.id}",button_on: @user.enabled? } }
                   end
                 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 => GraderConfiguration['system.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 => GraderConfiguration['system.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
                 private
                   def user_params
                     params.require(:user).permit(:login, :full_name, :email)
                   end
               end

app/models/user.rb ¶ +15

                   end
                   return false
                 end
                 def available_problems_group_by_contests
                   contest_problems = []
                   pin = {}
                   contests.enabled.each do |contest|
                     available_problems = contest.problems.available
                     contest_problems << {
                       :contest => contest,
                       :problems => available_problems
                     }
                     available_problems.each {|p| pin[p.id] = true}
                   end
                   other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
                   contest_problems << {
                     :contest => nil,
                     :problems => other_avaiable_problems
                   }
                   return contest_problems
                 end
                 def solve_all_available_problems?
                   available_problems.each do |p|
                     u = self
                     sub = Submission.find_last_by_user_and_problem(u.id,p.id)
                     return false if !p or !sub or sub.points < p.full_score
                   end
                   return true
                 end
                 #get a list of available problem
                 def available_problems
                   # first, we check if this is normal mode
                   if not GraderConfiguration.multicontests?
                     #if this is a normal mode
                     #we show problem based on problem_group, if the config said so
                     if GraderConfiguration.use_problem_group?
                       return available_problems_in_group
                     else
                       return Problem.available_problems
                     end
                   else
                     #this is multi contest mode
                     contest_problems = []
                     pin = {}
                     contests.enabled.each do |contest|
                       contest.problems.available.each do |problem|
                         if not pin.has_key? problem.id
                           contest_problems << problem
                         end
                         pin[problem.id] = true
                       end
                     end
                     other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
                     return contest_problems + other_avaiable_problems
                   end
                 end
                 # new feature, get list of available problem in all enabled group that the user belongs to
                 def available_problems_in_group
                   problem = []
                   self.groups.where(enabled: true).each do |group|
                     group.problems.where(available: true).each { |p| problem << p }
                   end
                   problem.uniq!
                   if problem
                     problem.sort! do |a,b|
                       case
                       when a.date_added < b.date_added
                       when a.date_added > b.date_added
                         -1
                       else
                         a.name <=> b.name
                       end
                     end
                     return problem
                   else
                     return []
                   end
                 end
                 #check if the user has the right to view that problem
                 #this also consider group based problem policy
                 def can_view_problem?(problem)
                   return true if admin?
                   return available_problems.include? problem
                 end
                 def self.clear_last_login
                   User.update_all(:last_ip => nil)
                 end
+            +   def get_jschart_user_sub_history
+            +     start = 4.month.ago.beginning_of_day
+            +     start_date = start.to_date
+            +     count = Submission.where(user: self).where('submitted_at >= ?', start).group('DATE(submitted_at)').count
+            +     i = 0
+            +     label = []
+            +     value = []
+            +     while (start_date + i < Time.zone.now.to_date)
+            +       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
+            +
                 #create multiple user, one per lines of input
                 def self.create_from_list(lines)
                   error_logins = []
                   first_error = nil
                   created_users = []
                   lines.split("\n").each do |line|
                     #split with large limit, this will cause consecutive ',' to be result in a blank
                     items = line.chomp.split(',',1000)
                     if items.length>=2
                       login = items[0]
                       full_name = items[1]
                       remark =''
                       user_alias = ''
                       added_random_password = false
                       added_password = false
                       #given password?
                       if items.length >= 3
                         if items[2].chomp(" ").length > 0
                           password = items[2].chomp(" ")
                           added_password = true
                         end
                       else
                         password = random_password
                         added_random_password=true;
                       end
                       #given alias?
                       if items.length>= 4 and items[3].chomp(" ").length > 0;
                         user_alias = items[3].chomp(" ")
                       else
                         user_alias = login
                       end
                       #given remark?
                       has_remark = false
                       if items.length>=5
                         remark = items[4].strip;
                         has_remark = true
                       end
                       user = User.find_by_login(login)
                       if (user)
                         user.full_name = full_name
                         user.remark = remark if has_remark
                         user.password = password if added_password || added_random_password
                       else
                         #create a random password if none are given
                         password = random_password unless password
                         user = User.new({:login => login,
                                          :full_name => full_name,
                                          :password => password,
                                          :password_confirmation => password,
                                          :alias => user_alias,
                                          :remark => remark})
                       end
                       user.activated = true
                       if user.save
                         created_users << user
                       else
                         error_logins << "'#{login}'"
                         first_error = user.errors.full_messages.to_sentence unless first_error
                       end
                     end
                   end
                   return {error_logins: error_logins, first_error: first_error, created_users: created_users}
                 end
                 def self.find_non_admin_with_prefix(prefix='')
                   users = User.all
                   return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
                 end
                 protected
                   def encrypt_new_password
                     return if password.blank?
                     self.salt = (10+rand(90)).to_s
                     self.hashed_password = User.encrypt(self.password,self.salt)
                   end
                   def assign_default_site
                     # have to catch error when migrating (because self.site is not available).
                     begin
                       if self.site==nil
                         self.site = Site.find_by_name('default')
                         if self.site==nil
                           self.site = Site.find(1)  # when 'default has be renamed'
                         end
                       end
                     rescue
                     end

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

               - if submission.nil?
                 = "-"
               - else
                 - if local_assigns[:show_id]
                   .row
-            -       .col-3.text-secondary
+            +       .col-3.fw-bold
-            -         Sub ID:
+            +         Sub ID
-            -       %strong.col-9= submission.id
+            +       .col-9.text-secondary-x= submission.id
                 - unless submission.graded_at
                   .row
-            -       .col-3.text-secondary= t 'main.submitted_at'
+            +       .col-3.fw-bold= t 'main.submitted_at'
-            -       %strong.col-9= format_full_time_ago(submission.submitted_at.localtime)
+            +       .col-9.text-secondary-x= format_full_time_ago(submission.submitted_at.localtime)
                 - else
                   .row
-            -       .col-3.text-secondary= t 'main.graded_at'
+            +       .col-3.fw-bold= t 'main.graded_at'
-            -       %strong.col-9= format_full_time_ago(submission.graded_at.localtime)
+            +       .col-9.text-secondary-x= format_full_time_ago(submission.graded_at.localtime)
                   - if GraderConfiguration['ui.show_score']
                     .row
-            -         .col-3.text-secondary=t 'main.score'
+            +         .col-3.fw-bold=t 'main.score'
-            -         %strong.col-9
+            +         .col-9.text-secondary-x
                         = (submission.points*100/submission.problem.full_score).to_i
                         %tt.grader-comment
                           = " [#{submission.grader_comment}]"
                 - if local_assigns[:show_button]
                   - if submission.graded_at
                     - if GraderConfiguration.show_grading_result
                       = link_to '[detailed result]', :action => 'result', :id => submission.id
                     = link_to "#{t 'main.cmp_msg'}", compiler_msg_submission_path(submission), {popup: true,remote: true,class: 'btn btn-sm btn-info'}
                   = link_to "#{t 'main.src_link'}",download_submission_path(submission), class: 'btn btn-sm btn-info'
                   = link_to "#{t 'main.submissions_link'}", problem_submissions_path(submission.problem.id), class: 'btn btn-sm btn-info'
                   - if GraderConfiguration.show_testcase
                     = link_to "testcases", show_problem_testcases_path(submission.problem.id), class: 'btn btn-sm btn-info'

app/views/problems/manage.html.haml ¶ +44 -34

               - content_for :head do
                 = stylesheet_link_tag 'problems'
                 = javascript_include_tag 'local_jquery'
-            - :javascript
-            -   $(document).ready( function() {
-            -     function shiftclick(start,stop,value) {
-            -       $('tr input').each( function(id,input) {
-            -         var $input=$(input);
-            -         var iid=parseInt($input.attr('id').split('-')[2]);
-            -         if(iid>=start&&iid<=stop){
-            -         $input.prop('checked',value)
-            -         }
-            -       });
-            -     }
-            -     $('tr input').click( function(e)  {
-            -       if (e.shiftKey) {
-            -         stop = parseInt($(this).attr('id').split('-')[2]);
-            -         var orig_stop = stop
-            -         if (typeof start !== 'undefined') {
-            -           if (start > stop) {
-            -             var tmp = start;
-            -             start = stop;
-            -             stop = tmp;
-            -           }
-            -           shiftclick(start,stop,$(this).is(':checked') )
-            -         }
-            -         start = orig_stop
-            -       } else {
-            -         start = parseInt($(this).attr('id').split('-')[2]);
-            -       }
-            -     });
-            -   });
               %h1 Manage problems
               %p= link_to '[Back to problem list]', problems_path
-            - = form_tag :action=>'do_manage' do
+            + = form_with url: do_manage_problems_path do |f|
-            -   .panel.panel-primary
+            +   .card.border-primary.mb-2
-            -     .panel-heading
+            +     .card-header.text-bg-primary.border-primary
                     Action
-            -     .panel-body
+            +     .card-body
                     .submit-box
                       What do you want to do to the selected problem?
                       %br/
                       (You can shift-click to select a range of problems)
+            +         .row
+            +           .col-md-auto
+            +             = f.check_box :change_date_added, class: 'form-check-input'
+            +           .col-md-auto
+            +             .form-check-label
+            +               Change "Date added" to
+            +           .col-md-auto
+            +
                       %ul.form-inline
                         %li
                           Change "Date added" to
                           .input-group.date
                             = text_field_tag :date_added, class: 'form-control'
                             %span.input-group-addon
                               %span.glyphicon.glyphicon-calendar
                           -# = select_date Date.current, :prefix => 'date_added'
                           &nbsp;&nbsp;&nbsp;
                           = submit_tag 'Change', :name => 'change_date_added', class: 'btn btn-primary btn-sm'
                         %li
                           Set "Available" to
                           = submit_tag 'True', :name => 'enable_problem', class: 'btn btn-primary btn-sm'
                           = submit_tag 'False', :name => 'disable_problem', class: 'btn btn-primary btn-sm'
                         - if GraderConfiguration.multicontests?
                           %li
                             Add selected problems to contest
                             = select("contest","id",Contest.all.collect {|c| [c.title, c.id]})
                             = submit_tag 'Add', :name => 'add_to_contest', class: 'btn btn-primary btn-sm'
                         %li
                           Add selected problems to user group
                           = select_tag "group_id", options_from_collection_for_select( Group.all, 'id','name',params[:group_name]), id: 'group_name',class: 'select2'
                           = submit_tag 'Add', name: 'add_group', class: 'btn btn-primary'
                         %li
                           Add the following tags to the selected problems
                           = select_tag "tag_ids", options_from_collection_for_select( Tag.all, 'id','name'), id: 'tags_name',class: 'select2', multiple: true, data: {placeholder: 'Select tags by clicking', width: "200px"}
                           = submit_tag 'Add', name: 'add_tags', class: 'btn btn-primary'
                 %table.table.table-hover.datatable
                   %thead
                     %tr{style: "text-align: left;"}
                       %th= check_box_tag 'select_all'
                       %th Name
                       %th Full name
                       %th Tags
                       %th Available
                       %th Date added
                       - if GraderConfiguration.multicontests?
                         %th Contests
                   %tbody
                     - num = 0
                     - for problem in @problems
                       - num += 1
                       %tr{:id => "row-prob-#{problem.id}", :name=> "prob-#{problem.id}"}
                         %td= check_box_tag "prob-#{problem.id}-#{num}"
                         %td= problem.name
                         %td= problem.full_name
                         %td
                           - problem.tags.each do |t|
                             %span.label.label-default= t.name
                         %td= problem.available
                         %td= problem.date_added
                         - if GraderConfiguration.multicontests?
                           %td
                             - problem.contests.each do |contest|
                               = "(#{contest.name} [#{link_to 'x', :action => 'remove_contest', :id => problem.id, :contest_id => contest.id }])"
               :javascript
+            +
+            +   $(document).on('import-map-loaded', function() {
+            +     function shiftclick(start,stop,value) {
+            +       $('tr input').each( function(id,input) {
+            +         var $input=$(input);
+            +         var iid=parseInt($input.attr('id').split('-')[2]);
+            +         if(iid>=start&&iid<=stop){
+            +         $input.prop('checked',value)
+            +         }
+            +       });
+            +     }
+            +
+            +     $('tr input').click( function(e)  {
+            +       if (e.shiftKey) {
+            +         stop = parseInt($(this).attr('id').split('-')[2]);
+            +         var orig_stop = stop
+            +         if (typeof start !== 'undefined') {
+            +           if (start > stop) {
+            +             var tmp = start;
+            +             start = stop;
+            +             stop = tmp;
+            +           }
+            +           shiftclick(start,stop,$(this).is(':checked') )
+            +         }
+            +         start = orig_stop
+            +       } else {
+            +         start = parseInt($(this).attr('id').split('-')[2]);
+            +       }
+            +     });
+            +
                   $('.input-group.date').datetimepicker({
                     format: 'DD/MMM/YYYY',
                     showTodayButton: true,
                     locale: 'en',
                     widgetPositioning: {horizontal: 'auto', vertical: 'bottom'},
                   });
+            +
                   $('.datatable').DataTable({
                     paging: false
                   });
+            +   });

app/views/problems/stat.html.haml ¶ +41 -14

               :css
                 .fix-width {
                   font-family: "Consolas, Monaco, Droid Sans Mono,Mono, Monospace,Courier"
                 }
               %h1 Problem stat: #{@problem.name}
-            - %h2 Overview
+            + .row.mb-3
+            +   .col-md-8
+            +     .card
+            +       .card-body
+            +         %h2.card-title Submission History
+            +         %canvas#chart{height: '50px'}
+            +
+            +   .col-md-4
+            +     .card
+            +       .card-body
+            +         %h2.card-title General Info
                       .row
-            -   .col-md-2
+            +           .col-sm-6
-            -     %strong Name:
+            +             Name
-            -   .col-md-10
+            +           .col-sm-6
                           = @problem.full_name #in_place_editor_field :problem, :full_name, {}, :rows=>1
                           = link_to_description_if_any "[#{t 'main.problem_desc'}] <span class='glyphicon glyphicon-file'></span>".html_safe, @problem
                       .row
-            -   .col-md-2.strong
+            +           .col-sm-6
-            -     %strong Submissions:
+            +             Subs
-            -   .col-md-10
+            +           .col-sm-6
                           = @submissions.count
                       .row
-            -   .col-md-2.strong
+            +           .col-sm-6
-            -     %strong Solved/Attemped User
+            +             Solved/Attempted User
-            -   .col-md-10
+            +           .col-sm-6
                           #{@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#main_table.table.table-condensed.table-striped
                   %thead
                     %tr
                       %th ID
                       %th Login
                       %th Name
                       %th Submitted_at
                       %th language
                       %th Points
                       %th comment
                       %th IP
                   %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
                         %td= link_to sub.id, submission_path(sub)
                         %td= link_to sub.user.login, stat_user_path(sub.user)
                         %td= sub.user.full_name
                         %td{data: {order: sub.submitted_at}}= time_ago_in_words(sub.submitted_at) + " ago"
                         %td= sub.language.name
                         %td= sub.points
                         %td.fix-width= sub.grader_comment
                         %td= sub.ip_address
               - else
                 No submission
               :javascript
+            +   $(document).on('import-map-loaded',(e) => {
+            +     //init datatable
                   $("#main_table").DataTable({
                     paging: false
                   });
+            +
+            +     //history graph
+            +     data = #{@chart_dataset}
+            +     config = {
+            +       type: 'bar',
+            +       data: data,
+            +       options: {
+            +         plugins: {
+            +           legend: {
+            +             display: false
+            +           },
+            +         },
+            +       }
+            +     }
+            +     Chart.defaults.font.size = 15
+            +     //Chart.defaults.font.family = 'Sarabun Light'
+            +     chart = new Chart($('#chart'),config)
+            +   });
+            +

app/views/users/stat.html.haml ¶ +56 -31

@@ -1,70 +1,95
1	- - content_for :header do
2	- = javascript_include_tag 'local_jquery'
3	-
4	- :javascript
5	- $(function () {
6	- $('#submission_table').tablesorter({widgets: ['zebra']});
7	- });
8		1
9	:css	2	:css
10	.fix-width {	3	.fix-width {
11	font-family: Droid Sans Mono,Consolas, monospace, mono, Courier New, Courier;	4	font-family: Droid Sans Mono,Consolas, monospace, mono, Courier New, Courier;
12	}	5	}
13		6
14	- %h1= @user.full_name	7	+ %h1 User stats
		8	+ %h5.text-secondary= @user.login
		9	+
		10	+ .row.my-3
		11	+ .col-md-8
		12	+ .card
		13	+ .card-body
		14	+ %h2.card-title Sub Info
		15	+ %canvas#chart{height: '50px'}
15		16
16	- <b>Login:</b> #{@user.login} <br/>	17	+ .col-md-4
17	- <b>Full name:</b> #{@user.full_name} <br />	18	+ .card
		19	+ .card-body
		20	+ %h2.card-title General Info
		21	+ .row
		22	+ .col-sm-6.fw-bold
		23	+ Login
		24	+ .col-sm-6
		25	+ = @user.login
		26	+ .row
		27	+ .col-sm-6.fw-bold
		28	+ Full name
		29	+ .col-sm-6
		30	+ = @user.full_name
		31	+ .row
		32	+ .col-sm-6.fw-bold
		33	+ Subs
		34	+ .col-sm-6
		35	+ = @summary[:count]
		36	+ .row
		37	+ .col-sm-6.fw-bold
		38	+ Solved/Attempted Problem
		39	+ .col-sm-6
		40	+ #{@summary[:solve]}/#{@summary[:attempt]} (#{(@summary[:solve]*100.0/@summary[:attempt]).round(1)}%)
18		41
19		42
20	- %h2 Problem Stat	43	+ %table#main_table.table.table-striped
21	- %table.info
22	- %thead
23	- %tr.info-head
24	- %th Stat
25	- %th Value
26	- %tbody
27	- %tr{class: cycle('info-even','info-odd')}
28	- %td.info_param Submissions
29	- %td= @summary[:count]
30	- %tr{class: cycle('info-even','info-odd')}
31	- %td.info_param Solved/Attempted Problem
32	- %td #{@summary[:solve]}/#{@summary[:attempt]} (#{(@summary[:solve]*100.0/@summary[:attempt]).round(1)}%)
33	-
34	- %h2 Submission History
35	-
36	- =render partial: 'application/bar_graph', locals: {histogram: @histogram, param: {bar_width: 7}}
37	-
38	-
39	- %table#submission_table.table.table-striped
40	%thead	44	%thead
41	%tr	45	%tr
42	%th ID	46	%th ID
43	%th Problem code	47	%th Problem code
44	%th Problem full name	48	%th Problem full name
45	%th Language	49	%th Language
46	%th Submitted at	50	%th Submitted at
47	%th Result	51	%th Result
48	%th Score	52	%th Score
49	- if session[:admin]	53	- if session[:admin]
50	%th IP	54	%th IP
51	%tbody	55	%tbody
52	- @submission.each do \|s\|	56	- @submission.each do \|s\|
53	- next unless s.problem	57	- next unless s.problem
54	%tr	58	%tr
55	%td= link_to s.id, submission_path(s)	59	%td= link_to s.id, submission_path(s)
56	%td= link_to s.problem.name, stat_problem_path(s.problem)	60	%td= link_to s.problem.name, stat_problem_path(s.problem)
57	%td= s.problem.full_name	61	%td= s.problem.full_name
58	%td= s.language.pretty_name	62	%td= s.language.pretty_name
59	%td #{s.submitted_at.strftime('%Y-%m-%d %H:%M')} (#{time_ago_in_words(s.submitted_at)} ago)	63	%td #{s.submitted_at.strftime('%Y-%m-%d %H:%M')} (#{time_ago_in_words(s.submitted_at)} ago)
60	%td.fix-width= s.grader_comment	64	%td.fix-width= s.grader_comment
61	%td= ( s.try(:points) ? (s.points*100/s.problem.full_score) : '' )	65	%td= ( s.try(:points) ? (s.points*100/s.problem.full_score) : '' )
62	- if session[:admin]	66	- if session[:admin]
63	%td= s.ip_address	67	%td= s.ip_address
64		68
65		69
66		70
67	:javascript	71	:javascript
68	- $("#submission_table").DataTable({	72	+ $(document).on('import-map-loaded',(e) => {
		73	+ //init datatable
		74	+ $("#main_table").DataTable({
69	paging: false	75	paging: false
70	});	76	});
		77	+
		78	+ //history graph
		79	+ data = #{@chart_dataset}
		80	+ config = {
		81	+ type: 'bar',
		82	+ data: data,
		83	+ options: {
		84	+ plugins: {
		85	+ legend: {
		86	+ display: false
		87	+ },
		88	+ },
		89	+ }
		90	+ }
		91	+ Chart.defaults.font.size = 15
		92	+ //Chart.defaults.font.family = 'Sarabun Light'
		93	+ chart = new Chart($('#chart'),config)
		94	+ });
		95	+

app/views/application/_bar_graph.html.haml removed ¶ -44

deleted file

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

r880:31e27f513ce9 - Fri, 07 Oct 2022 04:48:27 - 9 files changed: 173 inserted, 142 deleted

Sign in to your account

Commit r880:31e27f513ce9 public

Author

r880:31e27f513ce9 - Fri, 07 Oct 2022 04:48:27 - 9 files changed: 173 inserted, 142 deleted

Commit `r880:31e27f513ce9` public