cafe-grader-web Commit - r680:4ce0b8696d06

cafe-grader-web

Commit `r680:4ce0b8696d06` public

parent | child

Description:

add remove_all in groups consolidate submissions viewing from grader/task

Commit status:

[Not Reviewed]

References:

java

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r680:4ce0b8696d06 - Thu, 14 Sep 2017 14:45:10 - 9 files changed: 35 inserted, 138 deleted

app/controllers/graders_controller.rb ¶ +1 -36

               class GradersController < ApplicationController
-            -   before_filter :admin_authorization, except: [ :submission ]
+            +   before_filter :admin_authorization
-            -   before_filter(only: [:submission]) {
-            -     #check if authenticated
-            -     return false unless authenticate
-            -     #admin always has privileged
-            -     if @current_user.admin?
-            -       return true
-            -     end
-            -     if GraderConfiguration["right.user_view_submission"] and Submission.find(params[:id]).problem.available?
-            -       return true
-            -     else
-            -       unauthorized_redirect
-            -       return false
-            -     end
-            -   }
                 verify :method => :post, :only => ['clear_all',
                                                    'start_exam',
                                                    'start_grading',
                                                    'stop_all',
                                                    'clear_terminated'],
                        :redirect_to => {:action => 'index'}
                 def index
                   redirect_to :action => 'list'
                 end
                 def list
                   @grader_processes = GraderProcess.find_running_graders
                   @stalled_processes = GraderProcess.find_stalled_process
                   @terminated_processes = GraderProcess.find_terminated_graders
                   @last_task = Task.last
                   @last_test_request = TestRequest.last
                   @submission = Submission.order("id desc").limit(20)
                   @backlog_submission = Submission.where('graded_at is null')
                 end
                 def clear
                   grader_proc = GraderProcess.find(params[:id])
                   grader_proc.destroy if grader_proc!=nil
                   redirect_to :action => 'list'
                 end
                 def clear_terminated
                   GraderProcess.find_terminated_graders.each do |p|
                     p.destroy
                   end
                   redirect_to :action => 'list'
                 end
                 def clear_all
                   GraderProcess.all.each do |p|
                     p.destroy
                   end
                   redirect_to :action => 'list'
                 end
                 def view
                   if params[:type]=='Task'
                     redirect_to :action => 'task', :id => params[:id]
                   else
                     redirect_to :action => 'test_request', :id => params[:id]
                   end
                 end
                 def test_request
                   @test_request = TestRequest.find(params[:id])
                 end
                 def task
                   @task = Task.find(params[:id])
                 end
-            -   def submission
-            -     @submission = Submission.find(params[:id])
-            -     formatter = Rouge::Formatters::HTML.new(css_class: 'highlight', line_numbers: true )
-            -     lexer = case @submission.language.name
-            -       when "c"      then Rouge::Lexers::C.new
-            -       when "cpp"    then Rouge::Lexers::Cpp.new
-            -       when "pas"    then Rouge::Lexers::Pas.new
-            -       when "ruby"   then Rouge::Lexers::Ruby.new
-            -       when "python" then Rouge::Lexers::Python.new
-            -       when "java"   then Rouge::Lexers::Java.new
-            -       when "php"    then Rouge::Lexers::PHP.new
-            -     end
-            -     @formatted_code = formatter.format(lexer.lex(@submission.source))
-            -     @css_style = Rouge::Themes::ThankfulEyes.render(scope: '.highlight')
-            -     user = User.find(session[:user_id])
-            -     SubmissionViewLog.create(user_id: session[:user_id],submission_id: @submission.id) unless user.admin?
-            -   end
                 # various grader controls
                 def stop
                   grader_proc = GraderProcess.find(params[:id])
                   GraderScript.stop_grader(grader_proc.pid)
                   flash[:notice] = 'Grader stopped.  It may not disappear now, but it should disappear shortly.'
                   redirect_to :action => 'list'
                 end
                 def stop_all
                   GraderScript.stop_graders(GraderProcess.find_running_graders +
                                             GraderProcess.find_stalled_process)
                   flash[:notice] = 'Graders stopped.  They may not disappear now, but they should disappear shortly.'
                   redirect_to :action => 'list'
                 end
                 def start_grading
                   GraderScript.start_grader('grading')
                   flash[:notice] = '2 graders in grading env started, one for grading queue tasks, another for grading test request'
                   redirect_to :action => 'list'
                 end
                 def start_exam
                   GraderScript.start_grader('exam')
                   flash[:notice] = '2 graders in grading env started, one for grading queue tasks, another for grading test request'
                   redirect_to :action => 'list'
                 end
               end

app/controllers/groups_controller.rb ¶ +12 -2

               class GroupsController < ApplicationController
                 before_action :set_group, only: [:show, :edit, :update, :destroy,
-            -                                    :add_user, :remove_user,
+            +                                    :add_user, :remove_user,:remove_all_user,
-            -                                    :add_problem, :remove_problem,
+            +                                    :add_problem, :remove_problem,:remove_all_problem,
                                                 ]
                 before_action :authenticate, :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 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)
                   end
               end

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

               class TasksController < ApplicationController
                 before_filter :authenticate, :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])
-            -     if !problem or !problem.available or !@user.can_view_problem? problem
+            +     unless @current_user.can_view_problem? problem
                     redirect_to :action => 'index' and return
                   end
                   base_name = params[:file]
                   base_filename = File.basename("#{base_name}.#{params[:ext]}")
                   filename = "#{Problem.download_file_basedir}/#{params[:id]}/#{base_filename}"
                   puts "SENDING: #{filename}"
                   if !FileTest.exists?(filename)
                     redirect_to :action => 'index' and return
                   end
                   puts "SENDING: #{filename}"
                   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/models/user.rb ¶ +2 -5

               require 'digest/sha1'
               require 'net/pop'
               require 'net/https'
               require 'net/http'
               require 'json'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
                 #has_and_belongs_to_many :groups
                 has_many :groups_users, class_name: GroupUser
                 has_many :groups, :through => :groups_users
                 has_many :test_requests, -> {order(submitted_at: DESC)}
                 has_many :messages, -> { order(created_at: DESC) },
                          :class_name => "Message",
                          :foreign_key => "sender_id"
                 has_many :replied_messages, -> { order(created_at: DESC) },
                          :class_name => "Message",
                          :foreign_key => "receiver_id"
                 has_one :contest_stat, :class_name => "UserContestStat", :dependent => :destroy
                 belongs_to :site
                 belongs_to :country
                 has_and_belongs_to_many :contests, -> { order(:name); uniq}
                 scope :activated_users, -> {where activated: true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /\A[\_A-Za-z0-9]+\z/
                 validates_length_of :login, :within => 3..30
                 validates_presence_of :full_name
                 validates_length_of :full_name, :minimum => 1
                 validates_presence_of :password, :if => :password_required?
                 validates_length_of :password, :within => 4..20, :if => :password_required?
                 validates_confirmation_of :password, :if => :password_required?
                 validates_format_of :email,
                                     :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i,
                                     :if => :email_validation?
                 validate :uniqueness_of_email_from_activated_users,
                          :if => :email_validation?
                 validate :enough_time_interval_between_same_email_registrations,
                          :if => :email_validation?
                 # these are for ytopc
                 # disable for now
                 #validates_presence_of :province
                 attr_accessor :password
                 before_save :encrypt_new_password
                 before_save :assign_default_site
                 before_save :assign_default_contest
                 # this is for will_paginate
                 cattr_reader :per_page
                 @@per_page = 50
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   if user
                     return user if user.authenticated?(password)
                     if user.authenticated_by_cucas?(password) or user.authenticated_by_pop3?(password)
                       user.password = password
                       user.save
                       return user
                     end
                   end
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def authenticated_by_pop3?(password)
                   Net::POP3.enable_ssl
                   pop = Net::POP3.new('pops.it.chula.ac.th')
                   authen = true
                   begin
                     pop.start(login, password)
                     pop.finish
                     return true
                   rescue
                     return false
                   end
                 end
                 def authenticated_by_cucas?(password)
                   url = URI.parse('https://www.cas.chula.ac.th/cas/api/?q=studentAuthenticate')
                   appid = '41508763e340d5858c00f8c1a0f5a2bb'
                   appsecret ='d9cbb5863091dbe186fded85722a1e31'
                   post_args = {
                     'appid' => appid,
                     'appsecret' => appsecret,
                     'username' => login,
                     'password' => password
                   }
                   #simple call
                   begin
                     http = Net::HTTP.new('www.cas.chula.ac.th', 443)
                     http.use_ssl = true
                     http.verify_mode = OpenSSL::SSL::VERIFY_NONE
                     result = [ ]
                     http.start do |http|
                       req = Net::HTTP::Post.new('/cas/api/?q=studentAuthenticate')
                       param = "appid=#{appid}&appsecret=#{appsecret}&username=#{login}&password=#{password}"
                       resp = http.request(req,param)
                       result = JSON.parse resp.body
                     end
                     return true if result["type"] == "beanStudent"
                   rescue => e
                     return false
                   end
                   return false
                 end
                 def admin?
                   self.roles.detect {|r| r.name == 'admin' }
                 end
                 def email_for_editing
                   if self.email==nil
                     "(unknown)"
                   elsif self.email==''
                     "(blank)"
                   else
                     self.email
                   end
                 end
                 def email_for_editing=(e)
                   self.email=e
                 end
                 def alias_for_editing
                   if self.alias==nil
                     "(unknown)"
                   elsif self.alias==''
                     "(blank)"
                   else
                     self.alias
                   end
                 end
                 def alias_for_editing=(e)
                   self.alias=e
                 end
                 def activation_key
                   if self.hashed_password==nil
                     encrypt_new_password
                   end
                   Digest::SHA1.hexdigest(self.hashed_password)[0..7]
                 end
                 def verify_activation_key(key)
                   key == activation_key
                 end
                 def self.random_password(length=5)
                   chars = 'abcdefghjkmnopqrstuvwxyz'
                   password = ''
                   length.times { password << chars[rand(chars.length - 1)] }
                   password
                 end
                 def self.find_non_admin_with_prefix(prefix='')
                   users = User.all
                   return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
                 end
                 # Contest information
                 def self.find_users_with_no_contest()
                   users = User.all
                   return users.find_all { |u| u.contests.length == 0 }
                 end
                 def contest_time_left
                   if GraderConfiguration.contest_mode?
                     return nil if site==nil
                     return site.time_left
                   elsif GraderConfiguration.indv_contest_mode?
                     time_limit = GraderConfiguration.contest_time_limit
                     if time_limit == nil
                       return nil
                     end
                     if contest_stat==nil or contest_stat.started_at==nil
                       return (Time.now.gmtime + time_limit) - Time.now.gmtime
                     else
                       finish_time = contest_stat.started_at + time_limit
                       current_time = Time.now.gmtime
                       if current_time > finish_time
                         return 0
                       else
                         return finish_time - current_time
                       end
                     end
                   else
                     return nil
                   end
                 end
                 def contest_finished?
                   if GraderConfiguration.contest_mode?
                     return false if site==nil
                     return site.finished?
                   elsif GraderConfiguration.indv_contest_mode?
                     return false if self.contest_stat(true)==nil
                     return contest_time_left == 0
                   else
                     return false
                   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
                 def available_problems
                   if not GraderConfiguration.multicontests?
                     if GraderConfiguration.use_problem_group?
                       return available_problems_in_group
                     else
                       return Problem.available_problems
                     end
                   else
                     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
                 def available_problems_in_group
                   problem = []
                   self.groups.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
                 def can_view_problem?(problem)
-            -     if not GraderConfiguration.multicontests?
+            +     return true if admin?
-            -       return problem.available
+            +     return available_problems.include? problem
-            -     else
-            -       return problem_in_user_contests? problem
-            -     end
                 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/graders/task.html.haml ¶ +1 -1

               %h1= "Task: #{@task.id}"
               %p
                 User:
                 = "#{@task.submission.user.login}"
                 %br/
                 Status:
                 = "#{@task.status_str} (at #{format_short_time(@task.updated_at)})"
                 %br/
                 = "Submission: #{@task.submission_id}"
                 - if @task.submission !=nil
-            -     = link_to '[view submission]', :action => 'submission', :id => @task.submission.id
+            +     = link_to '[view submission]', submission_path( @task.submission.id )
                 %br/
                 = "Submitted at: #{format_short_time(@task.created_at)}"
                 %br/

app/views/groups/show.html.haml ¶ +6 -5

               %p
                 %b Name:
                 = @group.name
               %p
                 %b Description:
                 = @group.description
               %br
               = link_to 'Edit', edit_group_path(@group)
               \|
               = link_to 'Back', groups_path
               .row
-            -   %h1 Group details
+            +   .col-md-12
+            +     %h1 Group details
               .row
                 .col-md-6
                   .panel.panel-default
                     .panel-heading
                       .panel-title Users in this group
                     .panel-body
                       =form_tag add_user_group_path(@group), class: 'form-inline' do
                         .form-group
                           =label_tag :user_id, "User"
                           =select_tag :user_id, options_from_collection_for_select(User.all,'id','full_name'), class: 'select2'
                         =submit_tag "Add",class: 'btn btn-primary'
                       %table.table.table-hover
                         %thead
                           %tr
                             %th Login
                             %th Full name
                             %th Remark
-            -               %th
+            +               %th= link_to 'Remove All', remove_all_user_group_path(@group), method: :delete, :data => { :confirm => "Remove ALL USERS from group?" }, class: 'btn btn-danger btn-sm'
                         %tbody
                           - @group.users.each do |user|
                             %tr
                               %td= user.login
                               %td= user.full_name
                               %td= user.remark
-            -                 %td= link_to 'Remove', remove_user_group_path(@group,user), :method => :delete, :data => { :confirm => "Remove #{user.full_name}?" }, class: 'btn btn-danger'
+            +                 %td= link_to 'Remove', remove_user_group_path(@group,user), :method => :delete, :data => { :confirm => "Remove #{user.full_name}?" }, class: 'btn btn-danger btn-sm'
                 .col-md-6
                   .panel.panel-default
                     .panel-heading
                       .panel-title Problems
                     .panel-body
                       =form_tag add_problem_group_path(@group), class: 'form-inline' do
                         .form-group
                           =label_tag :problem_id, "Problem"
                           =select_tag :problem_id, options_from_collection_for_select(Problem.all,'id','full_name'), class: 'select2'
                         =submit_tag "Add",class: 'btn btn-primary'
                       %table.table.table-hover
                         %thead
                           %tr
                             %th name
                             %th Full name
                             %th Full score
-            -               %th
+            +               %th= link_to 'Remove All', remove_all_problem_group_path(@group), method: :delete, :data => { :confirm => "Remove ALL PROBLEMS from group?" }, class: 'btn btn-danger btn-sm'
                         %tbody
                           - @group.problems.each do |problem|
                             %tr
                               %td= problem.name
                               %td= problem.full_name
                               %td= problem.full_score
-            -                 %td= link_to 'Remove', remove_problem_group_path(@group,problem), :method => :delete, :data => { :confirm => "Remove #{problem.full_name}?" }, class: 'btn btn-danger'
+            +                 %td= link_to 'Remove', remove_problem_group_path(@group,problem), :method => :delete, :data => { :confirm => "Remove #{problem.full_name}?" }, class: 'btn btn-danger btn-sm'

app/views/problems/index.html.haml ¶ +7 -1

               - content_for :head do
                 = stylesheet_link_tag 'problems'
               %h1 Problems
               %p
                 = link_to 'Import problems', {:action => 'import'}, class: 'btn btn-success btn-sm'
                 = link_to 'New problem', new_problem_path, class: 'btn btn-success btn-sm'
                 = link_to 'Bulk Manage', { action: 'manage'}, class: 'btn btn-info btn-sm'
                 = link_to 'Turn off all problems', {:action => 'turn_all_off'}, class: 'btn btn-default btn-sm'
                 = link_to 'Turn on all problems', {:action => 'turn_all_on'}, class: 'btn btn-default btn-sm'
               .submitbox
                 = form_tag :action => 'quick_create' do
                   %b Quick New:
                   %label{:for => "problem_name"} Name
                   = text_field 'problem', 'name'
                   |
                   %label{:for => "problem_full_name"} Full name
                   = text_field 'problem', 'full_name'
                   = submit_tag "Create"
               %table.table.table-condense.table-hover
                 %thead
                   %th Name
                   %th Full name
                   %th.text-right Full score
+            +     %th
+            +       Submit
+            +       %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Admin can always submit to any problem' } [?]
                   %th Date added
                   %th.text-center
                     Avail?
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Let user submits to this problem?' } [?]
                   %th.text-center
                     View Data?
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Let user view the testcase of this problem?' } [?]
                   %th.text-center
                     Test?
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Let user uses test interface on this problem?' } [?]
                   - if GraderConfiguration.multicontests?
                     %th Contests
                 - for problem in @problems
                   %tr{:class => "#{(problem.available) ? "success" : "danger"}", :id => "prob-#{problem.id}", :name => "prob-#{problem.id}"}
                     - @problem=problem
                     %td= problem.name #in_place_editor_field :problem, :name, {}, :rows=>1
-            -       %td= problem.full_name #in_place_editor_field :problem, :full_name, {}, :rows=>1
+            +       %td
+            +         = problem.full_name #in_place_editor_field :problem, :full_name, {}, :rows=>1
+            +         = link_to_description_if_any "[#{t 'main.problem_desc'}] <span class='glyphicon glyphicon-file'></span>".html_safe, problem
                     %td.text-right= problem.full_score #in_place_editor_field :problem, :full_score, {}, :rows=>1
+            +       %td= link_to "Submit", direct_edit_problem_submissions_path(problem), class: 'btn btn-xs btn-primary'
                     %td= problem.date_added
                     %td= toggle_button(@problem.available?, toggle_problem_path(@problem), "problem-avail-#{@problem.id}")
                     %td= toggle_button(@problem.view_testcase?, toggle_view_testcase_problem_path(@problem), "problem-view-testcase-#{@problem.id}")
                     %td= toggle_button(@problem.test_allowed?, toggle_test_problem_path(@problem), "problem-test-#{@problem.id}")
                     - if GraderConfiguration.multicontests?
                       %td
                         = problem.contests.collect { |c| c.name }.join(', ')
                     %td= link_to 'Stat', {:action => 'stat', :id => problem.id}, class: 'btn btn-info btn-xs btn-block'
                     %td= link_to 'Show', {:action => 'show', :id => problem}, class: 'btn btn-info btn-xs btn-block'
                     %td= link_to 'Edit', {:action => 'edit', :id => problem}, class: 'btn btn-info btn-xs btn-block'
                     %td= link_to 'Destroy', { :action => 'destroy', :id => problem }, :confirm => 'Are you sure?', :method => :delete, class: 'btn btn-danger btn-xs btn-block'
               %br/
               = link_to '[New problem]', :action => 'new'

config/routes.rb ¶ +5

               CafeGrader::Application.routes.draw do
                 get "sources/direct_edit"
                 root :to => 'main#login'
                 #logins
                 get 'login/login',  to: 'login#login'
                 resources :contests
                 resources :sites
                 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'
                   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'
+            +     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'
                 resources :users do
                   member do
                     get 'toggle_activate', 'toggle_enable'
                     get 'stat'
                   end
                 end
                 resources :submissions do
                   member do
                     get 'download'
                     get 'compiler_msg'
                     get 'rejudge'
                   end
                   collection do
                     get 'prob/:problem_id', to: 'submissions#index', as: 'problem'
                     get 'direct_edit_problem/:problem_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
                 #main
                 get "main/list"
                 get 'main/submission(/:id)', to: 'main#submission', as: 'main_submission'
                 #user admin
                 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'
                 #report
                 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'
                 #
                 get 'tasks/view/:file.:ext' => 'tasks#view'
                 get 'tasks/download/:id/:file.:ext' => 'tasks#download'
                 get 'heartbeat/:id/edit' => 'heartbeat#edit'
                 #grader
                 get 'graders/list', to: 'graders#list', as: 'grader_list'
                 # 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

app/views/graders/submission.html.haml removed ¶ -87

deleted file

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r680:4ce0b8696d06 - Thu, 14 Sep 2017 14:45:10 - 9 files changed: 35 inserted, 138 deleted

Sign in to your account

Commit r680:4ce0b8696d06 public

Author

r680:4ce0b8696d06 - Thu, 14 Sep 2017 14:45:10 - 9 files changed: 35 inserted, 138 deleted

Commit `r680:4ce0b8696d06` public