cafe-grader-web Commit - r834:825a2986c8ea

cafe-grader-web

Commit `r834:825a2986c8ea` public

parent | child

Description:

merge

Commit status:

[Not Reviewed]

References:

merge algo

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r834:825a2986c8ea - Tue, 25 Aug 2020 17:32:34 - 20 files changed: 150 inserted, 99 deleted

app/views/groups/toggle.js.haml created 644 ¶ +8

@@ -0,0 +1,8
	1	+ = render partial: 'toggle_button',
	2	+ locals: {button_id: "#group-enabled-#{@group.id}",button_on: @group.enabled }
	3	+ :plain
	4	+ r = $("#group-#{@group.id}");
	5	+ r.removeClass('success');
	6	+ r.removeClass('danger');
	7	+ r.addClass("#{@group.enabled? ? 'success' : 'danger'}");
	8	+

db/migrate/20200813083020_add_enabled_to_group.rb created 644 ¶ +5

@@ -0,0 +1,5
	1	+ class AddEnabledToGroup < ActiveRecord::Migration[5.2]
	2	+ def change
	3	+ add_column :groups, :enabled, :boolean, default: true
	4	+ end
	5	+ end

app/controllers/application_controller.rb ¶ +2 -1

                   #check if logged in
                   unless session[:user_id]
                     if GraderConfiguration[SINGLE_USER_MODE_CONF_KEY]
                       unauthorized_redirect('You need to login but you cannot log in at this time')
                     else
                       unauthorized_redirect('You need to login')
                     end
                     return false
                   end
                   # check if run in single user mode
                   if GraderConfiguration[SINGLE_USER_MODE_CONF_KEY]
                     if @current_user==nil || (!@current_user.admin?)
                       unauthorized_redirect('You cannot log in at this time')
                       return false
                     end
                   end
                   # check if the user is enabled
                   unless @current_user.enabled? || @current_user.admin?
                     unauthorized_redirect 'Your account is disabled'
                     return false
                   end
                   # check if user ip is allowed
                   unless @current_user.admin? || GraderConfiguration[WHITELIST_IGNORE_CONF_KEY]
                     unless is_request_ip_allowed?
                       unauthorized_redirect 'Your IP is not allowed to login at this time.'
                       return false
                     end
                   end
                   if GraderConfiguration.multicontests?
                     return true if @current_user.admin?
                     begin
                       if @current_user.contest_stat(true).forced_logout
                         flash[:notice] = 'You have been automatically logged out.'
                         redirect_to :controller => 'main', :action => 'index'
                       end
                     rescue
                     end
                   end
                   return true
                 end
                 #redirect to root (and also force logout)
                 #if the user use different ip from the previous connection
                 #  only applicable when MULTIPLE_IP_LOGIN options is false only
                 def authenticate_by_ip_address
                   #this assume that we have already authenticate normally
                   unless GraderConfiguration[MULTIPLE_IP_LOGIN_CONF_KEY]
                     user = User.find(session[:user_id])
                     if (!user.admin? && user.last_ip && user.last_ip != request.remote_ip)
                       flash[:notice] = "You cannot use the system from #{request.remote_ip}. Your last ip is #{user.last_ip}"
                       redirect_to :controller => 'main', :action => 'login'
                       return false
                     end
                     unless user.last_ip
                       user.last_ip = request.remote_ip
                       user.save
                     end
                   end
                   return true
                 end
                 def authorization
                   return false unless check_valid_login
                   user = User.find(session[:user_id])
                   unless user.roles.detect { |role|
                       role.rights.detect{ |right|
                         right.controller == self.class.controller_name and
                           (right.action == 'all' || right.action == action_name)
                       }
                     }
                     flash[:notice] = 'You are not authorized to view the page you requested'
                     #request.env['HTTP_REFERER'] ? (redirect_to :back) : (redirect_to :controller => 'login')
                     redirect_to :controller => 'main', :action => 'login'
                     return false
                   end
                 end
                 def verify_time_limit
                   return true if session[:user_id]==nil
                   user = User.find(session[:user_id], :include => :site)
                   return true if user==nil || user.site == nil
                   if user.contest_finished?
                     flash[:notice] = 'Error: the contest you are participating is over.'
                     redirect_to :back
                     return false
                   end
                   return true
                 end
                 def is_request_ip_allowed?
                   unless GraderConfiguration[WHITELIST_IGNORE_CONF_KEY]
                     user_ip = IPAddr.new(request.remote_ip)
+            +       allowed = GraderConfiguration[WHITELIST_IP_CONF_KEY] || ''
-            -       GraderConfiguration[WHITELIST_IP_CONF_KEY].delete(' ').split(',').each do |ips|
+            +       allowed.delete(' ').split(',').each do |ips|
                       allow_ips = IPAddr.new(ips)
                       if allow_ips.include?(user_ip)
                         return true
                       end
                     end
                     return false
                   end
                   return true
                 end
               end

app/controllers/groups_controller.rb ¶ +7 -1

               class GroupsController < ApplicationController
                 before_action :set_group, only: [:show, :edit, :update, :destroy,
                                                  :add_user, :remove_user,:remove_all_user,
                                                  :add_problem, :remove_problem,:remove_all_problem,
+            +                                    :toggle,
                                                 ]
                 before_action :admin_authorization
                 # GET /groups
                 def index
                   @groups = Group.all
                 end
                 # GET /groups/1
                 def show
                 end
                 # GET /groups/new
                 def new
                   @group = Group.new
                 end
                 # GET /groups/1/edit
                 def edit
                 end
                 # POST /groups
                 def create
                   @group = Group.new(group_params)
                   if @group.save
                     redirect_to @group, notice: 'Group was successfully created.'
                   else
                     render :new
                   end
                 end
                 # PATCH/PUT /groups/1
                 def update
                   if @group.update(group_params)
                     redirect_to @group, notice: 'Group was successfully updated.'
                   else
                     render :edit
                   end
                 end
                 # DELETE /groups/1
                 def destroy
                   @group.destroy
                   redirect_to groups_url, notice: 'Group was successfully destroyed.'
                 end
+            +   def toggle
+            +     @group.enabled = @group.enabled? ? false : true
+            +     @group.save
+            +   end
+            +
                 def remove_user
                   user = User.find(params[:user_id])
                   @group.users.delete(user)
                   redirect_to group_path(@group), flash: {success: "User #{user.login} was removed from the group #{@group.name}"}
                 end
                 def remove_all_user
                   @group.users.clear
                   redirect_to group_path(@group), alert: 'All users removed'
                 end
                 def remove_all_problem
                   @group.problems.clear
                   redirect_to group_path(@group), alert: 'All problems removed'
                 end
                 def add_user
                   user = User.find(params[:user_id])
                   begin
                     @group.users << user
                     redirect_to group_path(@group), flash: { success: "User #{user.login} was add to the group #{@group.name}"}
                   rescue => e
                     redirect_to group_path(@group), alert: e.message
                   end
                 end
                 def remove_problem
                   problem = Problem.find(params[:problem_id])
                   @group.problems.delete(problem)
                   redirect_to group_path(@group), flash: {success: "Problem #{problem.name} was removed from the group #{@group.name}" }
                 end
                 def add_problem
                   problem = Problem.find(params[:problem_id])
                   begin
                     @group.problems << problem
                     redirect_to group_path(@group), flash: {success: "Problem #{problem.name} was add to the group #{@group.name}" }
                   rescue => e
                     redirect_to group_path(@group), alert: e.message
                   end
                 end
                 private
                   # Use callbacks to share common setup or constraints between actions.
                   def set_group
                     @group = Group.find(params[:id])
                   end
                   # Only allow a trusted parameter "white list" through.
                   def group_params
-            -       params.require(:group).permit(:name, :description)
+            +       params.require(:group).permit(:name, :description, :enabled)
                   end
               end

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

                 def source
                   submission = Submission.find(params[:id])
                   if ((submission.user_id == session[:user_id]) and
                       (submission.problem != nil) and
                       (submission.problem.available))
                     send_data(submission.source,
                               {:filename => submission.download_filename,
                                 :type => 'text/plain'})
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def compiler_msg
                   @submission = Submission.find(params[:id])
                   if @submission.user_id == session[:user_id]
                     render :action => 'compiler_msg', :layout => 'empty'
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def result
                   if !GraderConfiguration.show_grading_result
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   prepare_grading_result(@submission)
                 end
                 def load_output
                   if !GraderConfiguration.show_grading_result or params[:num]==nil
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   case_num = params[:num].to_i
                   out_filename = output_filename(@user.login,
                                                  @submission.problem.name,
                                                  @submission.id,
                                                  case_num)
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   if defined?(USE_APACHE_XSENDFILE) and USE_APACHE_XSENDFILE
                     response.headers['Content-Type'] = "application/force-download"
                     response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
                     response.headers["X-Sendfile"] = out_filename
                     response.headers['Content-length'] = File.size(out_filename)
                     render :nothing => true
                   else
                     send_file out_filename, :stream => false, :filename => "output-#{case_num}.txt", :type => "text/plain"
                   end
                 end
                 def error
                   @user = User.find(session[:user_id])
                 end
                 # announcement refreshing and hiding methods
                 def announcements
                   if params.has_key? 'recent'
                     prepare_announcements(params[:recent])
                   else
                     prepare_announcements
                   end
                   render(:partial => 'announcement',
                          :collection => @announcements,
                          :locals => {:announcement_effect => true})
                 end
                 def confirm_contest_start
                   user = User.find(session[:user_id])
                   if request.method == 'POST'
                     user.update_start_time
                     redirect_to :action => 'list'
                   else
                     @contests = user.contests
                     @user = user
                   end
                 end
+            +
                 protected
                 def prepare_announcements(recent=nil)
                   if GraderConfiguration.show_tasks_to?(@user)
                     @announcements = Announcement.published(true)
                   else
                     @announcements = Announcement.published
                   end
                   if recent!=nil
                     recent_id = recent.to_i
                     @announcements = @announcements.find_all { |a| a.id > recent_id }
                   end
                 end
                 def prepare_list_information
                   @user = User.find(session[:user_id])
                   if not GraderConfiguration.multicontests?
                     @problems = @user.available_problems
                   else
                     @contest_problems = @user.available_problems_group_by_contests
                     @problems = @user.available_problems
                   end
                   @prob_submissions = {}
                   @problems.each do |p|
                     sub = Submission.find_last_by_user_and_problem(@user.id,p.id)
                     if sub!=nil
                       @prob_submissions[p.id] = { :count => sub.number, :submission => sub }
                     else
                       @prob_submissions[p.id] = { :count => 0, :submission => nil }
                     end
                   end
                   prepare_announcements
                 end
                 def check_viewability
                   @user = User.find(session[:user_id])
                   if (!GraderConfiguration.show_tasks_to?(@user)) and
                       ((action_name=='submission') or (action_name=='submit'))
                     redirect_to :action => 'list' and return
                   end
                 end
                 def prepare_grading_result(submission)
                   if GraderConfiguration.task_grading_info.has_key? submission.problem.name
                     grading_info = GraderConfiguration.task_grading_info[submission.problem.name]
                   else
                     # guess task info from problem.full_score
                     cases = submission.problem.full_score / 10
                     grading_info = {
                       'testruns' => cases,
                       'testcases' => cases
                     }
                   end
                   @test_runs = []
                   if grading_info['testruns'].is_a? Integer
                     trun_count = grading_info['testruns']
                     trun_count.times do |i|
                       @test_runs << [ read_grading_result(@user.login,
                                                           submission.problem.name,
                                                           submission.id,
                                                           i+1) ]
                     end
                   else
                     grading_info['testruns'].keys.sort.each do |num|
                       run = []
                       testrun = grading_info['testruns'][num]
                       testrun.each do |c|
                         run << read_grading_result(@user.login,
                                                    submission.problem.name,
                                                    submission.id,
                                                    c)
                       end
                       @test_runs << run
                     end
                   end
                 end
                 def grading_result_dir(user_name, problem_name, submission_id, case_num)
                   return "#{GRADING_RESULT_DIR}/#{user_name}/#{problem_name}/#{submission_id}/test-result/#{case_num}"
                 end
                 def output_filename(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   return "#{dir}/output.txt"
                 end
                 def read_grading_result(user_name, problem_name, submission_id, case_num)
                   dir = grading_result_dir(user_name,problem_name, submission_id, case_num)
                   result_file_name = "#{dir}/result"
                   if !FileTest.exists?(result_file_name)
                     return {:num => case_num, :msg => 'program did not run'}
                   else
                     results = File.open(result_file_name).readlines
                     run_stat = extract_running_stat(results)
                     output_filename = "#{dir}/output.txt"
                     if FileTest.exists?(output_filename)

app/controllers/submissions_controller.rb ¶ +2 -2

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

app/controllers/tasks_controller.rb ¶ +5 -3

               class TasksController < ApplicationController
                 before_action :check_valid_login, :check_viewability
                 def index
                   redirect_to :action => 'list'
                 end
                 def list
                   @problems = @user.available_problems
                 end
                 # this has contest-wide access control
                 def view
                   base_name = params[:file]
                   base_filename = File.basename("#{base_name}.#{params[:ext]}")
                   filename = "#{Problem.download_file_basedir}/#{base_filename}"
                   if !FileTest.exists?(filename)
                     redirect_to :action => 'index' and return
                   end
                   send_file_to_user(filename, base_filename)
                 end
                 # this has problem-level access control
                 def download
                   problem = Problem.find(params[:id])
                   unless @current_user.can_view_problem? problem
-            -       flash[:notice] = 'You are not authorized to access this file'
+            +       flash[:error] = 'You are not authorized to access this file'
-            -       redirect_to :action => 'index' and return
+            +       redirect_to list_main_path
+            +       return
                   end
                   base_name = params[:file]
                   base_filename = File.basename("#{base_name}.#{params[:ext]}")
                   filename = "#{Problem.download_file_basedir}/#{params[:id]}/#{base_filename}"
                   if !FileTest.exists?(filename)
                     flash[:notice] = 'File does not exists'
-            -       redirect_to :action => 'index' and return
+            +       redirect_to list_main_path
+            +       return
                   end
                   send_file_to_user(filename, base_filename)
                 end
                 protected
                 def send_file_to_user(filename, base_filename)
                   if defined?(USE_APACHE_XSENDFILE) and USE_APACHE_XSENDFILE
                     response.headers['Content-Type'] = "application/force-download"
                     response.headers['Content-Disposition'] = "attachment; filename=\"#{File.basename(filename)}\""
                     response.headers["X-Sendfile"] = filename
                     response.headers['Content-length'] = File.size(filename)
                     render :nothing => true
                   else
                     if params[:ext]=='pdf'
                       content_type = 'application/pdf'
                     else
                       content_type = 'application/octet-stream'
                     end
                     send_file filename, :stream => false, :disposition => 'inline', :filename => base_filename, :type => content_type
                   end
                 end
                 def check_viewability
                   @user = User.find(session[:user_id])
                   if @user==nil or !GraderConfiguration.show_tasks_to?(@user)
                     redirect_to :controller => 'main', :action => 'list'
                     return false
                   end
                 end
               end

app/controllers/user_admin_controller.rb ¶ +15 -5

               require 'csv'
               class UserAdminController < ApplicationController
                 include MailHelperMethods
                 before_action :admin_authorization
                 def index
                   @user_count = User.count
                   if params[:page] == 'all'
                     @users = User.all
                     @paginated = false
                   else
                     @users = User.paginate :page => params[:page]
                     @paginated = true
                   end
                   @users = User.all
                   @hidden_columns = ['hashed_password', 'salt', 'created_at', 'updated_at']
                   @contests = Contest.enabled
                 end
                 def active
                   sessions = ActiveRecord::SessionStore::Session.where("updated_at >= ?", 60.minutes.ago)
                   @users = []
                   sessions.each do |session|
                     if session.data[:user_id]
                       @users << User.find(session.data[:user_id])
                     end
                   end
                 end
                 def show
                   @user = User.find(params[:id])
                 end
                 def new
                   @user = User.new
                 end
                 def create
                   @user = User.new(user_params)
                   @user.activated = true
                   if @user.save
                     flash[:notice] = 'User was successfully created.'
                     redirect_to :action => 'index'
                   else
                     render :action => 'new'
                   end
                 end
                 def clear_last_ip
                   @user = User.find(params[:id])
                   @user.last_ip = nil
                   @user.save
                   redirect_to action: 'index', page: params[:page]
                 end
                 def create_from_list
                   lines = params[:user_list]
                   note = []
                   error_note = []
                   error_msg = nil
                   ok_user = []
                   lines.split("\n").each do |line|
-            -       items = line.chomp.split(',')
+            +       #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
-            -         if items.length >= 3 and items[2].chomp(" ").length > 0;
+            +         added_password = false
-            -           password = items[2].chomp(" ")
+            +         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
                       if items.length>= 4 and items[3].chomp(" ").length > 0;
                         user_alias = items[3].chomp(" ")
                       else
                         user_alias = login
                       end
+            +
+            +         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.password = password
+            +           user.remark = remark if has_remark
-            -           user.remark = 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
                         if added_random_password
                           note << "'#{login}' (+)"
                         else
                           note << login
                         end
                         ok_user << user
                       else
                         error_note << "'#{login}'"
                         error_msg = user.errors.full_messages.to_sentence unless error_msg
                       end
                     end
                   end
                   #add to group
                   if params[:add_to_group]
                     group = Group.where(id: params[:group_id]).first
                     if group
                       group.users << ok_user
                     end
                   end
                   # show flash
                   if note.size > 0
                     flash[:success] = 'User(s) ' + note.join(', ') +
                       ' were successfully created.  ' +
                       '( (+) - created with random passwords.)'
                   end
                   if error_note.size > 0
                     flash[:error] = "Following user(s) failed to be created: " + error_note.join(', ') + ". The error of the first failed one are: " + error_msg;
                   end
                   redirect_to :action => 'index'
                 end
                 def edit
                   @user = User.find(params[:id])
                 end
                 def update
                   @user = User.find(params[:id])
                   if @user.update_attributes(user_params)
                     flash[:notice] = 'User was successfully updated.'
                     redirect_to :action => 'show', :id => @user
                   else
                     render :action => 'edit'
                   end
                 end
                 def destroy
                   User.find(params[:id]).destroy
                   redirect_to :action => 'index'
                 end
                 def user_stat
                   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 user_stat_max
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else

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

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

app/helpers/main_helper.rb ¶ +3 -9

               module MainHelper
-            -   def link_to_description_if_any(name, problem, options={})
+            +   def link_to_description_if_any(name, problem)
                   if !problem.url.blank?
-            -       return link_to name, problem.url, options
+            +       return link_to name, problem.url
                   elsif !problem.description_filename.blank?
-            -       #build a link to a problem (via task controller)
                     basename, ext = problem.description_filename.split('.')
-            -       options[:controller] = 'tasks'
+            +       return link_to name, download_task_path(problem.id,basename,ext), target: '_blank'
-            -       options[:action] = 'download'
-            -       options[:id] = problem.id
-            -       options[:file] = basename
-            -       options[:ext] = ext
-            -       return link_to name, options
                   else
                     return ''
                   end
                 end
               end

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

                   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
                   if self.language == nil
                     self.language = Submission.find_language_in_source(self.source,
                                                                        self.source_filename)
                   end
                 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?")
                   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?)
+            +       errors[:base] << "Authorization error: you have no right to submit to this problem" 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/models/user.rb ¶ +4 -1

                   end
                 end
                 def contest_started?
                   if GraderConfiguration.indv_contest_mode?
                     stat = self.contest_stat
                     return ((stat != nil) and (stat.started_at != nil))
                   elsif GraderConfiguration.contest_mode?
                     return true if site==nil
                     return site.started
                   else
                     return true
                   end
                 end
                 def update_start_time
                   stat = self.contest_stat
                   if stat.nil? or stat.started_at.nil?
                     stat ||= UserContestStat.new(:user => self)
                     stat.started_at = Time.now.gmtime
                     stat.save
                   end
                 end
                 def problem_in_user_contests?(problem)
                   problem_contests = problem.contests.all
                   if problem_contests.length == 0   # this is public contest
                     return true
                   end
                   contests.each do |contest|
                     if problem_contests.find {|c| c.id == contest.id }
                       return true
                     end
                   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.each do |group|
+            +     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
                 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
                   end
                   def assign_default_contest
                     # have to catch error when migrating (because self.site is not available).
                     begin
                       if self.contests.length == 0
                         default_contest = Contest.find_by_name(GraderConfiguration['contest.default_contest_name'])
                         if default_contest
                           self.contests = [default_contest]
                         end
                       end
                     rescue
                     end
                   end
                   def password_required?
                     self.hashed_password.blank? || !self.password.blank?
                   end
                   def self.encrypt(string,salt)
                     Digest::SHA1.hexdigest(salt + string)
                   end
                   def uniqueness_of_email_from_activated_users
                     user = User.activated_users.find_by_email(self.email)
                     if user and (user.login != self.login)
                       self.errors.add(:base,"Email has already been taken")
                     end
                   end
                   def enough_time_interval_between_same_email_registrations
                     return if !self.new_record?
                     return if self.activated
                     open_user = User.find_by_email(self.email,
                                                    :order => 'created_at DESC')
                     if open_user and open_user.created_at and
                         (open_user.created_at > Time.now.gmtime - 5.minutes)
                       self.errors.add(:base,"There are already unactivated registrations with this e-mail address (please wait for 5 minutes)")
                     end
                   end
                   def email_validation?
                     begin
                       return VALIDATE_USER_EMAILS
                     rescue
                       return false
                     end
                   end
               end

app/views/application/_submission.html.haml ¶ +1 -1

               %tr
                 %td{:align => "center"}
                   = submission.number
                 %td.text-right
                   = link_to "##{submission.id}", submission_path(submission.id)
                 %td
                   = l submission.submitted_at, format: :long
                   = "( #{time_ago_in_words(submission.submitted_at)} ago)"
                 %td
                   = submission.source_filename
                   = " (#{submission.language.pretty_name}) "
-            -     = link_to('[load]',{:action => 'source', :id => submission.id})
+            +     = link_to '[load]', download_submission_path(submission)
                 %td
                   - if submission.graded_at
                     = "Graded at #{format_short_time(submission.graded_at)}."
                     %br/
                     = "Score: #{(submission.points*100/submission.problem.full_score).to_i} " if GraderConfiguration['ui.show_score']
                     = " ["
                     %tt
                       = submission.grader_comment
                     = "]"
                 %td
                   = render :partial => 'compiler_message', :locals => {:compiler_message => submission.compiler_message }
                 %td
                   = link_to 'Edit', edit_submission_path(submission.id), class: 'btn btn-success'

app/views/groups/_form.html.haml ¶ +20 -9

@@ -1,16 +1,27
1	= form_for @group do \|f\|	1	= form_for @group do \|f\|
2	- if @group.errors.any?	2	- if @group.errors.any?
3	#error_explanation	3	#error_explanation
4	%h2= "#{pluralize(@group.errors.count, "error")} prohibited this group from being saved:"	4	%h2= "#{pluralize(@group.errors.count, "error")} prohibited this group from being saved:"
5	%ul	5	%ul
6	- @group.errors.full_messages.each do \|msg\|	6	- @group.errors.full_messages.each do \|msg\|
7	%li= msg	7	%li= msg
8	-	8	+ .row
9	- .form-group.field	9	+ .col-md-6
10	- = f.label :name	10	+ .form-group.field
11	- = f.text_field :name, class: 'form-control'	11	+ = f.label :name
12	- .form-group.field	12	+ = f.text_field :name, class: 'form-control'
13	- = f.label :description	13	+ .row
14	- = f.text_field :description, class: 'form-control'	14	+ .col-md-6
15	- .form-group.~~actions~~	15	+ .form-group.field
16	- = f.submit 'Save', class: 'btn btn-primary'	16	+ = f.label :description
		17	+ = f.text_field :description, class: 'form-control'
		18	+ .row
		19	+ .col-md-6
		20	+ .checkbox
		21	+ = f.label :enabled do
		22	+ = f.check_box :enabled
		23	+ Enabled
		24	+ .row
		25	+ .col-md-6
		26	+ .form-group.actions
		27	+ = f.submit 'Save', class: 'btn btn-primary'

app/views/groups/index.html.haml ¶ +3 -1

               %h1 Groups
               %p
                 = link_to 'New Group', new_group_path, class: 'btn btn-primary'
               %table.table.table-hover
                 %thead
                   %tr
                     %th Name
                     %th Description
+            +       %th Enabled?
                     %th
                     %th
                 %tbody
                   - @groups.each do |group|
-            -       %tr
+            +       %tr{:class => "#{(group.enabled?) ? "success" : "danger"}", id: "group-#{group.id}"}
                       %td= group.name
                       %td= group.description
+            +         %td= toggle_button(group.enabled?, toggle_group_path(group), "group-enabled-#{group.id}", size: ' ', block: ' ')
                       %td= link_to 'View', group, class: 'btn btn-default'
                       %td= link_to 'Destroy', group, :method => :delete, :data => { :confirm => 'Are you sure?' }, class: 'btn btn-danger'
               %br

app/views/main/help.html.haml ¶ +1 -1

               = user_title_bar(@user)
               .announcementbox
                 %span{:class => 'title'}
                   =raw t 'help.how_to_submit'
                 .announcement
                   %p
                     =raw t 'help.must_specify_language'
                   %p
                     =raw t 'help.list_available_language'
                   %table{:border => '1'}
                     %tr
                       %th{:width => '150px'} C
                       %th{:width => '150px'} C++
                       %th{:width => '150px'} Pascal
                     %tr
                       %td=raw "<tt>/*<br/>LANG: C<br/>*/</tt>"
                       %td=raw "<tt>/*<br/>LANG: C++<br/>*/</tt>"
                       %td=raw "<tt>{<br/>LANG: Pascal<br/>}</tt>"
                   %p
                     =raw t 'help.accept_only_language_specified'
                   %p
                     =raw t 'help.specifying_task'
                   %p
                     =raw t 'help.example_cpp'
                   %table{:border => '1'}
                     %tr
                       %td{:width => '300px'}
                         %tt <tt>/*<br/>LANG: C++<br/>TASK: mobiles<br/>*/</tt>
                   %p
                     =raw t 'help.example_pas'
                   %table{:border => '1'}
                     %tr
                       %td{:width => '300px'}
                         %tt <tt>{<br/>LANG: Pascal<br/>TASK: mobiles<br/>}</tt>
                   %p
-            -       = raw(t('help.ask_questions_at_messages',:message_link_name => (t 'menu.messages'),:url => url_for(:controller => 'messages', :action => 'list')))
+            +       = raw(t('help.ask_questions_at_messages',:message_link_name => (t 'menu.messages'),url: messages_path ))

app/views/submissions/show.html.haml ¶ +1

               %h1= "Submission: #{@submission.id}"
               %textarea#data{style: "display:none;"}
                 :preserve
                   #{@submission.source}
               //%div.highlight{:style => "border: 1px solid black;"}
               //=@formatted_code.html_safe
               .containter
                 .row
                   .col-md-7
                     %h2 Source Code
                   .col-md-5
                     %h2 Stat
                 .row
                   .col-md-7
                     %div#editor{ style: "font-size: 14px; height: 400px; border-radius:5px;" }
                     :javascript
                       e = ace.edit("editor")
                       e.setOptions({ maxLines: Infinity })
                       e.setValue($("#data").text())
                       e.gotoLine(1)
                       e.getSession().setMode("#{get_ace_mode(@submission.language)}")
                       e.setReadOnly(true)
                   .col-md-5
                     %table.table.table-striped
                       %tr
                         %td.text-right
                           %strong User
                         %td
                           - if @submission.user
                             = link_to "#{@submission.user.login}", stat_user_path(@submission.user)
                             = @submission.user.full_name
                           - else
                             = "(n/a)"
                       %tr
                         %td.text-right
                           %strong Task
                         %td
                           - if @submission.problem!=nil
                             = link_to "[#{@submission.problem.name}]", stat_problem_path(@submission.problem)
                             = @submission.problem.full_name
+            +               = link_to_description_if_any "[download] <span class='glyphicon glyphicon-file'></span>".html_safe, @submission.problem
                           - else
                             = "(n/a)"
                       %tr
                         %td.text-right
                           %strong Tries
                         %td= @submission.number
                       %tr
                         %td.text-right
                           %strong Language
                         %td= @submission.language.pretty_name
                       %tr
                         %td.text-right
                           %strong Submitted
                         %td #{time_ago_in_words(@submission.submitted_at)} ago (at #{@submission.submitted_at.to_formatted_s(:long)})
                       %tr
                         %td.text-right
                           %strong Graded
                         - if @submission.graded_at
                           %td #{time_ago_in_words(@submission.graded_at)} ago (at #{@submission.graded_at.to_formatted_s(:long)})
                         - else
                           %td -
                       %tr
                         %td.text-right
                           %strong Points
                         %td #{@submission.points}/#{@submission.try(:problem).try(:full_score)}
                       %tr
                         %td.text-right
                           %strong Comment
                         %td #{@submission.grader_comment}
                       %tr
                         %td.text-right
                           %strong Runtime (s)
                         %td #{@submission.max_runtime}
                       %tr
                         %td.text-right
                           %strong Memory (kb)
                         %td #{@submission.peak_memory}
                       %tr
                         %td.text-right
                           %strong Compiler result
                         %td
                           %button.btn.btn-info.btn-xs{type: 'button', data: {toggle: 'modal', target: '#compiler'}}
                             view
                       - if session[:admin]
                         %tr
                           %td.text-right
                             %strong IP
                           %td #{@submission.ip_address}
                       %tr
                         %td.text-right
                           %strong Grading Task Status
                         %td
                           = @task.status_str if @task
                           - if session[:admin]
                             = link_to "rejudge", rejudge_submission_path, data: {remote: true}, class: 'btn btn-info btn-xs'
               .modal.fade#compiler{tabindex: -1,role: 'dialog'}
                 .modal-dialog.modal-lg{role:'document'}
                   .modal-content
                     .modal-header
                       %button.close{type: 'button', data: {dismissed: :modal}, aria: {label: 'close'}}
                         %span{aria: {hidden: 'true'}, data: {dismiss: 'modal'}} &times;
                       %h4 Compiler message
                     .modal-body
                       %pre#compiler_msg= @submission.compiler_message
                     .modal-footer
                       %button.btn.btn-default{type: 'button', data: {dismiss: 'modal'}} Close

app/views/user_admin/new_list.html.haml ¶ +9

               .container-fluid
                 .row
                   .col-md-6
                     %h1 Adding list of users
                 .row
                   .col-md-6
                     .panel.panel-default
                       .panel-heading
                         .panel-title Info
                       .panel-body
                         %ul
                           %li
                             List of user information in this format:
                             %tt user_id,name(,passwd(,alias(,remark)))
                           %li
                             Note that
                             %tt passwd, alias
                             and
                             %tt remark
                             is optional.
                           %li
                             When
                             %tt passwd
                             or
                             %tt alias
                             is empty, the original value will be used instead.
                           %li
                             If the users with the same user_id already exists, existing information will be overwritten.
+            +           Example:
+            +           %ol
+            +             %li
+            +               %pre user1,Somchai Jaidee
+            +               will create (or update) a user with login "user1" and setting the fullname to "Somchai Jaidee", also setting a random password.
+            +             %li
+            +               %pre user1,Somchai Jaidee,
+            +               will create (or update) a user with login "user1" and and setting the fullname "Somchai Jaidee". No change is made to the password unless this is a new user. If this is a new user, a random password will be generated.
+            +
                 .row
                   .col-md-6
                     = form_tag :action => 'create_from_list' do
                       .form-group
                         = submit_tag 'Create following users',class: 'btn btn-success'
                       .form-group
                         .div.checkbox
                           %label
                             = check_box_tag :add_to_group
                             Also add these users to the following group
                           = select_tag "group_id", options_from_collection_for_select( Group.all, 'id','name',params[:group_name]), id: 'group_name',class: 'select2'
                       .form-group
                         = text_area_tag 'user_list', nil, :rows => 50, :cols => 80
                   .col-md-6

config/routes.rb ¶ +2 -2

               Rails.application.routes.draw do
                 resources :tags
                 get "sources/direct_edit"
                 root :to => 'main#login'
                 #logins
                 match 'login/login',  to: 'login#login', via: [:get,:post]
                 resources :contests
                 resources :sites
                 resources :test
                 resources :messages do
                   member do
                     get 'hide'
                     post 'reply'
                   end
                   collection do
                     get 'console'
                     get 'list_all'
                   end
                 end
                 resources :announcements do
                   member do
                     get 'toggle','toggle_front'
                   end
                 end
                 resources :problems do
                   member do
                     get 'toggle'
                     get 'toggle_test'
                     get 'toggle_view_testcase'
                     get 'stat'
                   end
                   collection do
                     get 'turn_all_off'
                     get 'turn_all_on'
                     get 'import'
                     get 'manage'
                     get 'quick_create'
                     post 'do_manage'
                     post 'do_import'
                   end
                 end
                 resources :groups do
                   member do
                     post 'add_user', to: 'groups#add_user', as: 'add_user'
                     delete 'remove_user/:user_id', to: 'groups#remove_user', as: 'remove_user'
                     delete 'remove_all_user', to: 'groups#remove_all_user', as: 'remove_all_user'
                     post 'add_problem', to: 'groups#add_problem', as: 'add_problem'
                     delete 'remove_problem/:problem_id', to: 'groups#remove_problem', as: 'remove_problem'
                     delete 'remove_all_problem', to: 'groups#remove_all_problem', as: 'remove_all_problem'
+            +       get 'toggle'
                   end
                   collection do
                   end
                 end
                 resources :testcases, only: [] do
                   member do
                     get 'download_input'
                     get 'download_sol'
                   end
                   collection do
                     get 'show_problem/:problem_id(/:test_num)' => 'testcases#show_problem', as: 'show_problem'
                   end
                 end
                 resources :grader_configuration, controller: 'configurations' do
                   collection do
                     get 'set_exam_right(/:value)', action: 'set_exam_right', as: 'set_exam_right'
                   end
                 end
                 resources :users do
                   member do
                     get 'toggle_activate', 'toggle_enable'
                     get 'stat'
                   end
                   collection do
                     get 'profile'
                     post 'chg_passwd'
                   end
                 end
                 resources :submissions do
                   member do
                     get 'download'
                     get 'compiler_msg'
                     get 'rejudge'
-            -       get 'source'
                   end
                   collection do
                     get 'prob/:problem_id', to: 'submissions#index', as: 'problem'
                     get 'direct_edit_problem/:problem_id(/:user_id)', to: 'submissions#direct_edit_problem', as: 'direct_edit_problem'
                     get 'get_latest_submission_status/:uid/:pid', to: 'submissions#get_latest_submission_status', as: 'get_latest_submission_status'
                   end
                 end
                 #user admin
                 resources :user_admin  do
                   collection do
                     match 'bulk_manage', via: [:get, :post]
                     get 'bulk_mail'
                     get 'user_stat'
                     get 'import'
                     get 'new_list'
                     get 'admin'
                     get 'active'
                     get 'mass_mailing'
                     get 'revoke_admin'
                     post 'grant_admin'
                     match 'create_from_list', via: [:get, :post]
                     match 'random_all_passwords', via: [:get, :post]
                   end
                   member do
                     get 'clear_last_ip'
                   end
                 end
                 resources :contest_management, only: [:index] do
                   collection do
                     get 'user_stat'
                     get 'clear_stat'
                     get 'clear_all_stat'
                     get 'change_contest_mode'
                   end
                 end
                 #get 'user_admin', to: 'user_admin#index'
                 #get 'user_admin/bulk_manage', to: 'user_admin#bulk_manage', as: 'bulk_manage_user_admin'
                 #post 'user_admin', to: 'user_admin#create'
                 #delete 'user_admin/:id', to: 'user_admin#destroy', as: 'user_admin_destroy'
                 #singular resource
                 #---- BEWARE ---- singular resource maps to plural controller by default, we can override by provide controller name directly
                 #report
                 resource :report, only: [], controller: 'report' do
                   get 'login'
                   get 'multiple_login'
                   get 'problem_hof(/:id)', action: 'problem_hof', as: 'problem_hof'
                   get 'current_score(/:group_id)', action: 'current_score', as: 'current_score'
                   get 'max_score'
                   post 'show_max_score'
                   get 'stuck'
                   get 'cheat_report'
                   post 'cheat_report'
                   get 'cheat_scruntinize'
                   post 'cheat_scruntinize'
                 end
                 #get 'report/current_score', to: 'report#current_score', as: 'report_current_score'
                 #get 'report/problem_hof(/:id)', to: 'report#problem_hof', as: 'report_problem_hof'
                 #get "report/login"
                 #get 'report/max_score', to: 'report#max_score', as: 'report_max_score'
                 #post 'report/show_max_score', to: 'report#show_max_score', as: 'report_show_max_score'
                 resource :main, only: [], controller: 'main' do
                   get 'login'
                   get 'logout'
                   get 'list'
                   get 'submission(/:id)', action: 'submission', as: 'main_submission'
                   get 'announcements'
                   get 'help'
                   post 'submit'
                 end
                 #main
                 #get "main/list"
                 #get 'main/submission(/:id)', to: 'main#submission', as: 'main_submission'
                 #post 'main/submit', to: 'main#submit'
                 #get 'main/announcements', to: 'main#announcements'
                 #
                 get 'tasks/view/:file.:ext' => 'tasks#view'
-            -   get 'tasks/download/:id/:file.:ext' => 'tasks#download'
+            +   get 'tasks/download/:id/:file.:ext' => 'tasks#download', as: 'download_task'
                 get 'heartbeat/:id/edit' => 'heartbeat#edit'
                 #grader
                 get 'graders/list', to: 'graders#list', as: 'grader_list'
                 namespace :graders do
                   get 'task/:id/:type', action: 'task', as: 'task'
                   get 'view/:id/:type', action: 'view', as: 'view'
                   get 'clear/:id', action: 'clear', as: 'clear'
                   get 'stop'
                   get 'stop_all'
                   get 'clear_all'
                   get 'clear_terminated'
                   get 'start_grading'
                   get 'start_exam'
                 end
                 # See how all your routes lay out with "rake routes"
                 # This is a legacy wild controller route that's not recommended for RESTful applications.
                 # Note: This route will make all actions in every controller accessible via GET requests.
                 # match ':controller(/:action(/:id))(.:format)', via:  [:get, :post]
               end

db/schema.rb ¶ +58 -57

               # 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: 2018_06_12_102327) do
+            + ActiveRecord::Schema.define(version: 2020_08_13_083020) do
-            -   create_table "announcements", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "announcements", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "author"
                   t.text "body"
                   t.boolean "published"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                   t.boolean "frontpage", default: false
                   t.boolean "contest_only", default: false
                   t.string "title"
                   t.string "notes"
                 end
-            -   create_table "contests", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "contests", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "title"
                   t.boolean "enabled"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                   t.string "name"
                 end
-            -   create_table "contests_problems", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "contests_problems", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "contest_id"
                   t.integer "problem_id"
                 end
-            -   create_table "contests_users", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "contests_users", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "contest_id"
                   t.integer "user_id"
                 end
-            -   create_table "countries", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "countries", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "name"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                 end
-            -   create_table "descriptions", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "descriptions", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.text "body"
                   t.boolean "markdowned"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                 end
-            -   create_table "grader_configurations", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "grader_configurations", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "key"
                   t.string "value_type"
                   t.string "value"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                   t.text "description"
                 end
-            -   create_table "grader_processes", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "grader_processes", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "host"
                   t.integer "pid"
                   t.string "mode"
                   t.boolean "active"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                   t.integer "task_id"
                   t.string "task_type"
                   t.boolean "terminated"
-            -     t.index ["host", "pid"], name: "index_grader_processes_on_host_and_pid"
+            +     t.index ["host", "pid"], name: "index_grader_processes_on_ip_and_pid"
                 end
                 create_table "groups", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.string "name"
                   t.string "description"
+            +     t.boolean "enabled", default: true
                 end
                 create_table "groups_problems", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "problem_id", null: false
                   t.integer "group_id", null: false
                   t.index ["group_id", "problem_id"], name: "index_groups_problems_on_group_id_and_problem_id"
                 end
                 create_table "groups_users", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "group_id", null: false
                   t.integer "user_id", null: false
                   t.index ["user_id", "group_id"], name: "index_groups_users_on_user_id_and_group_id"
                 end
-            -   create_table "heart_beats", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "heart_beats", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "user_id"
                   t.string "ip_address"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                   t.string "status"
                   t.index ["updated_at"], name: "index_heart_beats_on_updated_at"
                 end
-            -   create_table "languages", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "languages", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "name", limit: 10
                   t.string "pretty_name"
                   t.string "ext", limit: 10
                   t.string "common_ext"
                 end
-            -   create_table "logins", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "logins", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "user_id"
                   t.string "ip_address"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                 end
-            -   create_table "messages", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "messages", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "sender_id"
                   t.integer "receiver_id"
                   t.integer "replying_message_id"
                   t.text "body"
                   t.boolean "replied"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                 end
-            -   create_table "problems", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "problems", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "name", limit: 30
                   t.string "full_name"
                   t.integer "full_score"
                   t.date "date_added"
                   t.boolean "available"
                   t.string "url"
                   t.integer "description_id"
                   t.boolean "test_allowed"
                   t.boolean "output_only"
                   t.string "description_filename"
                   t.boolean "view_testcase"
                 end
                 create_table "problems_tags", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "problem_id"
                   t.integer "tag_id"
                   t.index ["problem_id", "tag_id"], name: "index_problems_tags_on_problem_id_and_tag_id", unique: true
                   t.index ["problem_id"], name: "index_problems_tags_on_problem_id"
                   t.index ["tag_id"], name: "index_problems_tags_on_tag_id"
                 end
-            -   create_table "rights", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "rights", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "name"
                   t.string "controller"
                   t.string "action"
                 end
-            -   create_table "rights_roles", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "rights_roles", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "right_id"
                   t.integer "role_id"
                   t.index ["role_id"], name: "index_rights_roles_on_role_id"
                 end
-            -   create_table "roles", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "roles", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "name"
                 end
-            -   create_table "roles_users", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "roles_users", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "role_id"
                   t.integer "user_id"
                   t.index ["user_id"], name: "index_roles_users_on_user_id"
                 end
-            -   create_table "sessions", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "sessions", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "session_id"
                   t.text "data"
                   t.datetime "updated_at"
                   t.index ["session_id"], name: "index_sessions_on_session_id"
                   t.index ["updated_at"], name: "index_sessions_on_updated_at"
                 end
-            -   create_table "sites", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "sites", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "name"
                   t.boolean "started"
                   t.datetime "start_time"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                   t.integer "country_id"
                   t.string "password"
                 end
-            -   create_table "submission_view_logs", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "submission_view_logs", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "user_id"
                   t.integer "submission_id"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                 end
-            -   create_table "submissions", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "submissions", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "user_id"
                   t.integer "problem_id"
                   t.integer "language_id"
                   t.text "source", limit: 16777215
                   t.binary "binary"
                   t.datetime "submitted_at"
                   t.datetime "compiled_at"
                   t.text "compiler_message"
                   t.datetime "graded_at"
                   t.integer "points"
                   t.text "grader_comment"
                   t.integer "number"
                   t.string "source_filename"
                   t.float "max_runtime"
                   t.integer "peak_memory"
                   t.integer "effective_code_length"
                   t.string "ip_address"
                   t.index ["user_id", "problem_id", "number"], name: "index_submissions_on_user_id_and_problem_id_and_number", unique: true
                   t.index ["user_id", "problem_id"], name: "index_submissions_on_user_id_and_problem_id"
                 end
                 create_table "tags", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.string "name", null: false
                   t.text "description"
                   t.boolean "public"
                   t.datetime "created_at", null: false
                   t.datetime "updated_at", null: false
                 end
-            -   create_table "tasks", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "tasks", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "submission_id"
                   t.datetime "created_at"
                   t.integer "status"
                   t.datetime "updated_at"
                   t.index ["submission_id"], name: "index_tasks_on_submission_id"
                 end
-            -   create_table "test_pairs", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "test_pairs", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "problem_id"
                   t.text "input", limit: 16777215
                   t.text "solution", limit: 16777215
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                 end
-            -   create_table "test_requests", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "test_requests", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "user_id"
                   t.integer "problem_id"
                   t.integer "submission_id"
                   t.string "input_file_name"
                   t.string "output_file_name"
                   t.string "running_stat"
                   t.integer "status"
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                   t.datetime "submitted_at"
                   t.datetime "compiled_at"
                   t.text "compiler_message"
                   t.datetime "graded_at"
                   t.string "grader_comment"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
                   t.float "running_time"
                   t.string "exit_status"
                   t.integer "memory_usage"
                   t.index ["user_id", "problem_id"], name: "index_test_requests_on_user_id_and_problem_id"
                 end
                 create_table "testcases", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "problem_id"
                   t.integer "num"
                   t.integer "group"
                   t.integer "score"
                   t.text "input", limit: 4294967295
                   t.text "sol", limit: 4294967295
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.index ["problem_id"], name: "index_testcases_on_problem_id"
                 end
-            -   create_table "user_contest_stats", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "user_contest_stats", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.integer "user_id"
                   t.datetime "started_at"
-            -     t.datetime "created_at"
+            +     t.datetime "created_at", null: false
-            -     t.datetime "updated_at"
+            +     t.datetime "updated_at", null: false
                   t.boolean "forced_logout"
                 end
-            -   create_table "users", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
+            +   create_table "users", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci", force: :cascade do |t|
                   t.string "login", limit: 50
                   t.string "full_name"
                   t.string "hashed_password"
                   t.string "salt", limit: 5
                   t.string "alias"
                   t.string "email"
                   t.integer "site_id"
                   t.integer "country_id"
                   t.boolean "activated", default: false
                   t.datetime "created_at"
                   t.datetime "updated_at"
-            -     t.string "section"
                   t.boolean "enabled", default: true
                   t.string "remark"
                   t.string "last_ip"
+            +     t.string "section"
                   t.index ["login"], name: "index_users_on_login", unique: true
                 end
                 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

Commit r834:825a2986c8ea public

Author

r834:825a2986c8ea - Tue, 25 Aug 2020 17:32:34 - 20 files changed: 150 inserted, 99 deleted

Commit `r834:825a2986c8ea` public