cafe-grader-web Commit - r768:f22301d0d070

cafe-grader-web

Commit `r768:f22301d0d070` public

parent | child

Description:

Merge pull request #23 from nattee/master some bug fix

Commit status:

[Not Reviewed]

References:

merge default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r768:f22301d0d070 - Sun, 08 Jul 2018 08:15:42 - 7 files changed: 12 inserted, 5 deleted

db/migrate/20180612102327_change_submission_source_size.rb created 644 ¶ +5

@@ -0,0 +1,5
	1	+ class ChangeSubmissionSourceSize < ActiveRecord::Migration
	2	+ def change
	3	+ change_column :submissions, :source, :text, :limit => 1.megabyte
	4	+ end
	5	+ end

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

               class ProblemsController < ApplicationController
                 before_action :authenticate, :authorization
                 before_action :testcase_authorization, only: [:show_testcase]
                 in_place_edit_for :problem, :name
                 in_place_edit_for :problem, :full_name
                 in_place_edit_for :problem, :full_score
                 def index
                   @problems = Problem.order(date_added: :desc)
                 end
                 # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
                 verify :method => :post, :only => [ :create, :quick_create,
                                                     :do_manage,
                                                     :do_import,
                                                   ],
                        :redirect_to => { :action => :index }
                 def show
                   @problem = Problem.find(params[:id])
                 end
                 def new
                   @problem = Problem.new
                   @description = nil
                 end
                 def create
                   @problem = Problem.new(problem_params)
                   @description = Description.new(params[:description])
                   if @description.body!=''
                     if !@description.save
                       render :action => new and return
                     end
                   else
                     @description = nil
                   end
                   @problem.description = @description
                   if @problem.save
                     flash[:notice] = 'Problem was successfully created.'
                     redirect_to action: :index
                   else
                     render :action => 'new'
                   end
                 end
                 def quick_create
                   @problem = Problem.new(problem_params)
                   @problem.full_name = @problem.name if @problem.full_name == ''
                   @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
                   @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
                     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(problem_params)
                     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
                   p = Problem.find(params[:id]).destroy
                   redirect_to action: :index
                 end
                 def toggle
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(available: !(@problem.available) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def toggle_test
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(test_allowed: !(@problem.test_allowed?) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def toggle_view_testcase
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(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
                   @problem = Problem.find(params[:id])
                   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 }
                 end
                 def manage
                   @problems = Problem.order(date_added: :desc)
                 end
                 def do_manage
-            -     if params.has_key? 'change_date_added'
+            +     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
                   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
                 private
                   def problem_params
                     params.require(:problem).permit(:name, :full_name, :full_score, :date_added, :available, :test_allowed,:output_only, :url, :description, tag_ids:[])
                   end
               end

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

               require 'csv'
               class ReportController < ApplicationController
                 before_filter :authenticate
                 before_filter :admin_authorization, only: [:login_stat,:submission_stat, :stuck, :cheat_report, :cheat_scruntinize, :show_max_score, :current_score]
                 before_filter(only: [:problem_hof]) { |c|
                   return false unless authenticate
                   admin_authorization unless GraderConfiguration["right.user_view_submission"]
                 }
                 def max_score
                 end
                 def current_score
                   @problems = Problem.available_problems
                   @users = User.includes(:contests).includes(:contest_stat).where(enabled: true)
                   @scorearray = calculate_max_score(@problems, @users,0,0,true)
                   #rencer accordingly
                   if params[:button] == 'download' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'max_score.csv'
                   else
                     #render template: 'user_admin/user_stat'
                     render 'current_score'
                   end
                 end
                 def show_max_score
                   #process parameters
                   #problems
                   @problems = []
                   if params[:problem_id]
                     params[:problem_id].each do |id|
                       next unless id.strip != ""
                       pid = Problem.find_by_id(id.to_i)
                       @problems << pid if pid
                     end
                   end
                   #users
-            -     @users = if params[:user] == "all" then
+            +     @users = if params[:users] == "all" then
                              User.includes(:contests).includes(:contest_stat)
                            else
                              User.includes(:contests).includes(:contest_stat).where(enabled: true)
                            end
                   #set up range from param
                   @since_id = params.fetch(:from_id, 0).to_i
                   @until_id = params.fetch(:to_id, 0).to_i
                   @since_id = nil if @since_id == 0
                   @until_id = nil if @until_id == 0
                   #calculate the routine
                   @scorearray = calculate_max_score(@problems, @users, @since_id, @until_id)
                   #rencer accordingly
                   if params[:button] == 'download' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'max_score.csv'
                   else
                     #render template: 'user_admin/user_stat'
                     render 'max_score'
                   end
                 end
                 def score
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else
                     @problems = Problem.available_problems
                   end
                   @users = User.includes(:contests, :contest_stat).where(enabled: true)
                   @scorearray = Array.new
                   @users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     @problems.each do |p|
                       sub = Submission.find_last_by_user_and_problem(u.id,p.id)
                       if (sub!=nil) and (sub.points!=nil) and p and p.full_score
                         ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
                       else
                         ustat << [0,false]
                       end
                     end
                     @scorearray << ustat
                   end
                   if params[:commit] == 'download csv' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'last_score.csv'
                   else
                     render template: 'user_admin/user_stat'
                   end
                 end
                 def login_stat
                   @logins = Array.new
                   date_and_time = '%Y-%m-%d %H:%M'
                   begin
                     md = params[:since_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
                     @since_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
                   rescue
                     @since_time = DateTime.new(1000,1,1)
                   end
                   begin
                     md = params[:until_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
                     @until_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
                   rescue
                     @until_time = DateTime.new(3000,1,1)
                   end
                   User.all.each do |user|
                     @logins << { id: user.id,
                                  login: user.login,
                                  full_name: user.full_name,
                                  count: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .count(:id),
                                  min: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .minimum(:created_at),
                                  max: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .maximum(:created_at),
                                   ip: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .select(:ip_address).uniq
                                }
                   end
                 end
                 def submission_stat
                   date_and_time = '%Y-%m-%d %H:%M'
                   begin
                     @since_time = DateTime.strptime(params[:since_datetime],date_and_time)
                   rescue
                     @since_time = DateTime.new(1000,1,1)
                   end
                   begin
                     @until_time = DateTime.strptime(params[:until_datetime],date_and_time)
                   rescue
                     @until_time = DateTime.new(3000,1,1)
                   end
                   @submissions = {}
                   User.find_each do |user|
                     @submissions[user.id] = { login: user.login, full_name: user.full_name, count: 0, sub: { } }
                   end
                   Submission.where("submitted_at >= ? AND submitted_at <= ?",@since_time,@until_time).find_each do |s|
                     if @submissions[s.user_id]
                       if not @submissions[s.user_id][:sub].has_key?(s.problem_id)
                         a = Problem.find_by_id(s.problem_id)
                         @submissions[s.user_id][:sub][s.problem_id] =
                           { prob_name: (a ? a.full_name : '(NULL)'),
                             sub_ids: [s.id] }
                       else
                         @submissions[s.user_id][:sub][s.problem_id][:sub_ids] << s.id
                       end
                       @submissions[s.user_id][:count] += 1
                     end
                   end
                 end
                 def problem_hof
                   # gen problem list
                   @user = User.find(session[:user_id])
                   @problems = @user.available_problems
                   # get selected problems or the default
                   if params[:id]
                     begin
                       @problem = Problem.available.find(params[:id])
                     rescue
                       redirect_to action: :problem_hof
                       flash[:notice] = 'Error: submissions for that problem are not viewable.'
                       return
                     end
                   end
                   return unless @problem
                   @by_lang = {} #aggregrate by language
                   range =65
                   @histogram = { data: Array.new(range,0), summary: {} }
                   @summary = {count: 0, solve: 0, attempt: 0}
                   user = Hash.new(0)
                   Submission.where(problem_id: @problem.id).find_each do |sub|
                     #histogram
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     @histogram[:data][d.to_i] += 1 if d < range
                     next unless sub.points
                     @summary[:count] += 1
                     user[sub.user_id] = [user[sub.user_id], (sub.points >= @problem.full_score) ? 1 : 0].max
                     lang = Language.find_by_id(sub.language_id)
                     next unless lang
                     next unless sub.points >= @problem.full_score
                     #initialize
                     unless @by_lang.has_key?(lang.pretty_name)
                       @by_lang[lang.pretty_name] = {
                         runtime: { avail: false, value: 2**30-1 },
                         memory: { avail: false, value: 2**30-1 },
                         length: { avail: false, value: 2**30-1 },
                         first: { avail: false, value: DateTime.new(3000,1,1) }
                       }
                     end
                     if sub.max_runtime and sub.max_runtime < @by_lang[lang.pretty_name][:runtime][:value]
                       @by_lang[lang.pretty_name][:runtime] = { avail: true, user_id: sub.user_id, value: sub.max_runtime, sub_id: sub.id }
                     end
                     if sub.peak_memory and sub.peak_memory < @by_lang[lang.pretty_name][:memory][:value]
                       @by_lang[lang.pretty_name][:memory] = { avail: true, user_id: sub.user_id, value: sub.peak_memory, sub_id: sub.id }
                     end
                     if sub.submitted_at and sub.submitted_at < @by_lang[lang.pretty_name][:first][:value] and sub.user and
                         !sub.user.admin?
                       @by_lang[lang.pretty_name][:first] = { avail: true, user_id: sub.user_id, value: sub.submitted_at, sub_id: sub.id }
                     end
                     if @by_lang[lang.pretty_name][:length][:value] > sub.effective_code_length
                       @by_lang[lang.pretty_name][:length] = { avail: true, user_id: sub.user_id, value: sub.effective_code_length, sub_id: sub.id }
                     end
                   end

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

               class Submission < ActiveRecord::Base
                 belongs_to :language
                 belongs_to :problem
                 belongs_to :user
                 before_validation :assign_problem
                 before_validation :assign_language
                 validates_presence_of :source
-            -   validates_length_of :source, :maximum => 100_000, :allow_blank => true, :message => 'too long'
+            +   validates_length_of :source, :maximum => 100_000, :allow_blank => true, :message => 'code too long, the limit is 100,000 bytes'
                 validates_length_of :source, :minimum => 1, :allow_blank => true, :message => 'too short'
                 validate :must_have_valid_problem
                 validate :must_specify_language
                 has_one :task
                 before_save :assign_latest_number_if_new_recond
                 def self.find_last_by_user_and_problem(user_id, problem_id)
                   where("user_id = ? AND problem_id = ?",user_id,problem_id).last
                 end
                 def self.find_all_last_by_problem(problem_id)
                   # need to put in SQL command, maybe there's a better way
                   Submission.includes(:user).find_by_sql("SELECT * FROM submissions " +
               			   "WHERE id = " +
               			   "(SELECT MAX(id) FROM submissions AS subs " +
               			   "WHERE subs.user_id = submissions.user_id AND " +
                                          "problem_id = " + problem_id.to_s + " " +
               			   "GROUP BY user_id) " +
                                          "ORDER BY user_id")
                 end
                 def self.find_in_range_by_user_and_problem(user_id, problem_id,since_id,until_id)
                   records = Submission.where(problem_id: problem_id,user_id: user_id)
                   records = records.where('id >= ?',since_id) if since_id and since_id > 0
                   records = records.where('id <= ?',until_id) if until_id and until_id > 0
                   records.all
                 end
                 def self.find_last_for_all_available_problems(user_id)
                   submissions = Array.new
                   problems = Problem.available_problems
                   problems.each do |problem|
                     sub = Submission.find_last_by_user_and_problem(user_id, problem.id)
                     submissions << sub if sub!=nil
                   end
                   submissions
                 end
                 def self.find_by_user_problem_number(user_id, problem_id, number)
                   where("user_id = ? AND problem_id = ? AND number = ?",user_id,problem_id,number).first
                 end
                 def self.find_all_by_user_problem(user_id, problem_id)
                   where("user_id = ? AND problem_id = ?",user_id,problem_id)
                 end
                 def download_filename
                   if self.problem.output_only
                     return self.source_filename
                   else
                     timestamp = self.submitted_at.localtime.strftime("%H%M%S")
                     return "#{self.problem.name}-#{timestamp}.#{self.language.ext}"
                   end
                 end
                 protected
                 def self.find_option_in_source(option, source)
                   if source==nil
                     return nil
                   end
                   i = 0
                   source.each_line do |s|
                     if s =~ option
               	words = s.split
               	return words[1]
                     end
                     i = i + 1
                     if i==10
               	return nil
                     end
                   end
                   return nil
                 end
                 def self.find_language_in_source(source, source_filename="")
                   langopt = find_option_in_source(/^LANG:/,source)
                   if langopt
                     return (Language.find_by_name(langopt) ||
                             Language.find_by_pretty_name(langopt))
                   else
                     if source_filename
                       return Language.find_by_extension(source_filename.split('.').last)
                     else
                       return nil
                     end
                   end
                 end
                 def self.find_problem_in_source(source, source_filename="")
                   prob_opt = find_option_in_source(/^TASK:/,source)
                   if problem = Problem.find_by_name(prob_opt)
                     return problem
                   else
                     if source_filename
                       return Problem.find_by_name(source_filename.split('.').first)
                     else
                       return nil
                     end
                   end
                 end
                 def assign_problem
                   if self.problem_id!=-1
                     begin
                       self.problem = Problem.find(self.problem_id)
                     rescue ActiveRecord::RecordNotFound
                       self.problem = nil
                     end
                   else
                     self.problem = Submission.find_problem_in_source(self.source,
                                                                      self.source_filename)
                   end
                 end
                 def assign_language
                   self.language = Submission.find_language_in_source(self.source,
                                                                      self.source_filename)
                 end
                 # validation codes
                 def must_specify_language
                   return if self.source==nil
                   # for output_only tasks
                   return if self.problem!=nil and self.problem.output_only
                   if self.language==nil
                     errors.add('source',"Cannot detect language. Did you submit a correct source file?") unless self.language!=nil
                   end
                 end
                 def must_have_valid_problem
                   return if self.source==nil
                   if self.problem==nil
                     errors.add('problem',"must be specified.")
                   else
                     #admin always have right
                     return if self.user.admin?
                     #check if user has the right to submit the problem
                     errors.add('problem',"must be valid.") if (!self.user.available_problems.include?(self.problem)) and (self.new_record?)
                   end
                 end
                 # callbacks
                 def assign_latest_number_if_new_recond
                   return if !self.new_record?
                   latest = Submission.find_last_by_user_and_problem(self.user_id, self.problem_id)
                   self.number = (latest==nil) ? 1 : latest.number + 1;
                 end
               end

app/views/problems/manage.html.haml ¶ +1

               - 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
                 .panel.panel-primary
                   .panel-heading
                     Action
                   .panel-body
                     .submit-box
                       What do you want to do to the selected problem?
                       %br/
                       (You can shift-click to select a range of problems)
                       %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
                 $('.input-group.date').datetimepicker({
                   format: 'DD/MMM/YYYY',
                   showTodayButton: true,
+            +     locale: 'en',
                   widgetPositioning: {horizontal: 'auto', vertical: 'bottom'},
                 });
                 $('.datatable').DataTable({
                   paging: false
                 });

app/views/sites/edit.html.haml ¶ +1

               %h1 Editing site
               = error_messages_for :site
               = form_for(@site) do |f|
                 .row
                   .col-md-4
                     .form-group.field
                       = f.label :name, "Name"
                       = f.text_field :name, class: 'form-control'
                     .form-group.field
                       = f.label :password, "Password"
                       = f.text_field :password, class: 'form-control'
                     .form-group.field
                       = f.label :started, "Started"
                       = f.check_box :started, class: 'form-control'
                     .form-group.field
                       = f.label :start_time, "Start time"
                       -# = f.datetime_select :start_time, :include_blank => true
                       .input-group.date
                         = f.text_field :start_time, class:'form-control' , value: (@site.start_time ? @site.start_time.strftime('%d/%b/%Y %H:%M') : '')
                         %span.input-group-addon
                           %span.glyphicon.glyphicon-calendar
                     .actions
                       = f.submit "Update", class: 'btn btn-primary'
                   .col-md-8
               = link_to 'Show', @site
               |
               = link_to 'Back', sites_path
               :javascript
                 $('.input-group.date').datetimepicker({
                   format: 'DD/MMM/YYYY HH:mm',
+            +     locale: 'en',
                   showTodayButton: true,
                 });

db/schema.rb ¶ +2 -2

               # encoding: UTF-8
               # This file is auto-generated from the current state of the database. Instead
               # of editing this file, please use the migrations feature of Active Record to
               # incrementally modify your database, and then regenerate this schema definition.
               #
               # Note that this schema.rb definition is the authoritative source for your
               # database schema. If you need to create the application database on another
               # system, you should be using db:schema:load, not running all the migrations
               # from scratch. The latter is a flawed and unsustainable approach (the more migrations
               # you'll amass, the slower it'll run and the greater likelihood for issues).
               #
               # It's strongly recommended that you check this file into your version control system.
-            - ActiveRecord::Schema.define(version: 20170914150742) do
+            + ActiveRecord::Schema.define(version: 20180612102327) do
                 create_table "announcements", force: :cascade do |t|
                   t.string   "author",       limit: 255
                   t.text     "body",         limit: 65535
                   t.boolean  "published"
                   t.datetime "created_at",                                 null: false
                   t.datetime "updated_at",                                 null: false
                   t.boolean  "frontpage",                  default: false
                   t.boolean  "contest_only",               default: false
                   t.string   "title",        limit: 255
                   t.string   "notes",        limit: 255
                 end
                 create_table "contests", force: :cascade do |t|
                   t.string   "title",      limit: 255
                   t.boolean  "enabled"
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                   t.string   "name",       limit: 255
                 end
                 create_table "contests_problems", id: false, force: :cascade do |t|
                   t.integer "contest_id", limit: 4
                   t.integer "problem_id", limit: 4
                 end
                 create_table "contests_users", id: false, force: :cascade do |t|
                   t.integer "contest_id", limit: 4
                   t.integer "user_id",    limit: 4
                 end
                 create_table "countries", force: :cascade do |t|
                   t.string   "name",       limit: 255
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                 end
                 create_table "descriptions", force: :cascade do |t|
                   t.text     "body",       limit: 65535
                   t.boolean  "markdowned"
                   t.datetime "created_at",               null: false
                   t.datetime "updated_at",               null: false
                 end
                 create_table "grader_configurations", force: :cascade do |t|
                   t.string   "key",         limit: 255
                   t.string   "value_type",  limit: 255
                   t.string   "value",       limit: 255
                   t.datetime "created_at",                null: false
                   t.datetime "updated_at",                null: false
                   t.text     "description", limit: 65535
                 end
                 create_table "grader_processes", force: :cascade do |t|
                   t.string   "host",       limit: 255
                   t.integer  "pid",        limit: 4
                   t.string   "mode",       limit: 255
                   t.boolean  "active"
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                   t.integer  "task_id",    limit: 4
                   t.string   "task_type",  limit: 255
                   t.boolean  "terminated"
                 end
                 add_index "grader_processes", ["host", "pid"], name: "index_grader_processes_on_ip_and_pid", using: :btree
                 create_table "groups", force: :cascade do |t|
                   t.string "name",        limit: 255
                   t.string "description", limit: 255
                 end
                 create_table "groups_problems", id: false, force: :cascade do |t|
                   t.integer "problem_id", limit: 4, null: false
                   t.integer "group_id",   limit: 4, null: false
                 end
                 add_index "groups_problems", ["group_id", "problem_id"], name: "index_groups_problems_on_group_id_and_problem_id", using: :btree
                 create_table "groups_users", id: false, force: :cascade do |t|
                   t.integer "group_id", limit: 4, null: false
                   t.integer "user_id",  limit: 4, null: false
                 end
                 add_index "groups_users", ["user_id", "group_id"], name: "index_groups_users_on_user_id_and_group_id", using: :btree
                 create_table "heart_beats", force: :cascade do |t|
                   t.integer  "user_id",    limit: 4
                   t.string   "ip_address", limit: 255
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                   t.string   "status",     limit: 255
                 end
                 add_index "heart_beats", ["updated_at"], name: "index_heart_beats_on_updated_at", using: :btree
                 create_table "languages", force: :cascade do |t|
                   t.string "name",        limit: 10
                   t.string "pretty_name", limit: 255
                   t.string "ext",         limit: 10
                   t.string "common_ext",  limit: 255
                 end
                 create_table "logins", force: :cascade do |t|
                   t.integer  "user_id",    limit: 4
                   t.string   "ip_address", limit: 255
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                 end
                 create_table "messages", force: :cascade do |t|
                   t.integer  "sender_id",           limit: 4
                   t.integer  "receiver_id",         limit: 4
                   t.integer  "replying_message_id", limit: 4
                   t.text     "body",                limit: 65535
                   t.boolean  "replied"
                   t.datetime "created_at",                        null: false
                   t.datetime "updated_at",                        null: false
                 end
                 create_table "problems", force: :cascade do |t|
                   t.string  "name",                 limit: 30
                   t.string  "full_name",            limit: 255
                   t.integer "full_score",           limit: 4
                   t.date    "date_added"
                   t.boolean "available"
                   t.string  "url",                  limit: 255
                   t.integer "description_id",       limit: 4
                   t.boolean "test_allowed"
                   t.boolean "output_only"
                   t.string  "description_filename", limit: 255
                   t.boolean "view_testcase"
                 end
                 create_table "problems_tags", force: :cascade do |t|
                   t.integer "problem_id", limit: 4
                   t.integer "tag_id",     limit: 4
                 end
                 add_index "problems_tags", ["problem_id", "tag_id"], name: "index_problems_tags_on_problem_id_and_tag_id", unique: true, using: :btree
                 add_index "problems_tags", ["problem_id"], name: "index_problems_tags_on_problem_id", using: :btree
                 add_index "problems_tags", ["tag_id"], name: "index_problems_tags_on_tag_id", using: :btree
                 create_table "rights", force: :cascade do |t|
                   t.string "name",       limit: 255
                   t.string "controller", limit: 255
                   t.string "action",     limit: 255
                 end
                 create_table "rights_roles", id: false, force: :cascade do |t|
                   t.integer "right_id", limit: 4
                   t.integer "role_id",  limit: 4
                 end
                 add_index "rights_roles", ["role_id"], name: "index_rights_roles_on_role_id", using: :btree
                 create_table "roles", force: :cascade do |t|
                   t.string "name", limit: 255
                 end
                 create_table "roles_users", id: false, force: :cascade do |t|
                   t.integer "role_id", limit: 4
                   t.integer "user_id", limit: 4
                 end
                 add_index "roles_users", ["user_id"], name: "index_roles_users_on_user_id", using: :btree
                 create_table "sessions", force: :cascade do |t|
                   t.string   "session_id", limit: 255
                   t.text     "data",       limit: 65535
                   t.datetime "updated_at"
                 end
                 add_index "sessions", ["session_id"], name: "index_sessions_on_session_id", using: :btree
                 add_index "sessions", ["updated_at"], name: "index_sessions_on_updated_at", using: :btree
                 create_table "sites", force: :cascade do |t|
                   t.string   "name",       limit: 255
                   t.boolean  "started"
                   t.datetime "start_time"
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                   t.integer  "country_id", limit: 4
                   t.string   "password",   limit: 255
                 end
                 create_table "submission_view_logs", force: :cascade do |t|
                   t.integer  "user_id",       limit: 4
                   t.integer  "submission_id", limit: 4
                   t.datetime "created_at",              null: false
                   t.datetime "updated_at",              null: false
                 end
                 create_table "submissions", force: :cascade do |t|
                   t.integer  "user_id",               limit: 4
                   t.integer  "problem_id",            limit: 4
                   t.integer  "language_id",           limit: 4
-            -     t.text     "source",                limit: 65535
+            +     t.text     "source",                limit: 16777215
                   t.binary   "binary",                limit: 65535
                   t.datetime "submitted_at"
                   t.datetime "compiled_at"
                   t.text     "compiler_message",      limit: 65535
                   t.datetime "graded_at"
                   t.integer  "points",                limit: 4
                   t.text     "grader_comment",        limit: 65535
                   t.integer  "number",                limit: 4
                   t.string   "source_filename",       limit: 255
                   t.float    "max_runtime",           limit: 24
                   t.integer  "peak_memory",           limit: 4
                   t.integer  "effective_code_length", limit: 4
                   t.string   "ip_address",            limit: 255
                 end
                 add_index "submissions", ["user_id", "problem_id", "number"], name: "index_submissions_on_user_id_and_problem_id_and_number", unique: true, using: :btree
                 add_index "submissions", ["user_id", "problem_id"], name: "index_submissions_on_user_id_and_problem_id", using: :btree
                 create_table "tags", force: :cascade do |t|
                   t.string   "name",        limit: 255,   null: false
                   t.text     "description", limit: 65535
                   t.boolean  "public"
                   t.datetime "created_at",                null: false
                   t.datetime "updated_at",                null: false
                 end
                 create_table "tasks", force: :cascade do |t|
                   t.integer  "submission_id", limit: 4
                   t.datetime "created_at"
                   t.integer  "status",        limit: 4
                   t.datetime "updated_at"
                 end
                 add_index "tasks", ["submission_id"], name: "index_tasks_on_submission_id", using: :btree
                 create_table "test_pairs", force: :cascade do |t|
                   t.integer  "problem_id", limit: 4
                   t.text     "input",      limit: 16777215
                   t.text     "solution",   limit: 16777215
                   t.datetime "created_at",                  null: false
                   t.datetime "updated_at",                  null: false
                 end
                 create_table "test_requests", force: :cascade do |t|
                   t.integer  "user_id",          limit: 4
                   t.integer  "problem_id",       limit: 4
                   t.integer  "submission_id",    limit: 4
                   t.string   "input_file_name",  limit: 255
                   t.string   "output_file_name", limit: 255
                   t.string   "running_stat",     limit: 255
                   t.integer  "status",           limit: 4
                   t.datetime "updated_at",                     null: false
                   t.datetime "submitted_at"
                   t.datetime "compiled_at"
                   t.text     "compiler_message", limit: 65535
                   t.datetime "graded_at"
                   t.string   "grader_comment",   limit: 255
                   t.datetime "created_at",                     null: false
                   t.float    "running_time",     limit: 24
                   t.string   "exit_status",      limit: 255
                   t.integer  "memory_usage",     limit: 4
                 end
                 add_index "test_requests", ["user_id", "problem_id"], name: "index_test_requests_on_user_id_and_problem_id", using: :btree
                 create_table "testcases", force: :cascade do |t|
                   t.integer  "problem_id", limit: 4
                   t.integer  "num",        limit: 4
                   t.integer  "group",      limit: 4
                   t.integer  "score",      limit: 4
                   t.text     "input",      limit: 4294967295
                   t.text     "sol",        limit: 4294967295
                   t.datetime "created_at"
                   t.datetime "updated_at"
                 end
                 add_index "testcases", ["problem_id"], name: "index_testcases_on_problem_id", using: :btree
                 create_table "user_contest_stats", force: :cascade do |t|
                   t.integer  "user_id",       limit: 4
                   t.datetime "started_at"
                   t.datetime "created_at",              null: false
                   t.datetime "updated_at",              null: false
                   t.boolean  "forced_logout"
                 end
                 create_table "users", force: :cascade do |t|
                   t.string   "login",           limit: 50
                   t.string   "full_name",       limit: 255
                   t.string   "hashed_password", limit: 255
                   t.string   "salt",            limit: 5
                   t.string   "alias",           limit: 255
                   t.string   "email",           limit: 255
                   t.integer  "site_id",         limit: 4
                   t.integer  "country_id",      limit: 4
                   t.boolean  "activated",                   default: false
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.boolean  "enabled",                     default: true
                   t.string   "remark",          limit: 255
                   t.string   "last_ip",         limit: 255
                   t.string   "section",         limit: 255
                 end
                 add_index "users", ["login"], name: "index_users_on_login", unique: true, using: :btree
                 add_foreign_key "problems_tags", "problems"
                 add_foreign_key "problems_tags", "tags"
               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

r768:f22301d0d070 - Sun, 08 Jul 2018 08:15:42 - 7 files changed: 12 inserted, 5 deleted

Sign in to your account

Commit r768:f22301d0d070 public

Author

r768:f22301d0d070 - Sun, 08 Jul 2018 08:15:42 - 7 files changed: 12 inserted, 5 deleted

Commit `r768:f22301d0d070` public