cafe-grader-web Commit - r685:101d67319b73

cafe-grader-web

Commit `r685:101d67319b73` public

parent | child

Description:

merged

Commit status:

[Not Reviewed]

References:

merge java

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r685:101d67319b73 - Mon, 11 Sep 2017 15:59:08 - 43 files changed: 525 inserted, 159 deleted

app/controllers/groups_controller.rb created 644 ¶ +86

@@ -0,0 +1,86
	1	+ class GroupsController < ApplicationController
	2	+ before_action :set_group, only: [:show, :edit, :update, :destroy,
	3	+ :add_user, :remove_user,
	4	+ :add_problem, :remove_problem,
	5	+ ]
	6	+ before_action :authenticate, :admin_authorization
	7	+
	8	+ # GET /groups
	9	+ def index
	10	+ @groups = Group.all
	11	+ end
	12	+
	13	+ # GET /groups/1
	14	+ def show
	15	+ end
	16	+
	17	+ # GET /groups/new
	18	+ def new
	19	+ @group = Group.new
	20	+ end
	21	+
	22	+ # GET /groups/1/edit
	23	+ def edit
	24	+ end
	25	+
	26	+ # POST /groups
	27	+ def create
	28	+ @group = Group.new(group_params)
	29	+
	30	+ if @group.save
	31	+ redirect_to @group, notice: 'Group was successfully created.'
	32	+ else
	33	+ render :new
	34	+ end
	35	+ end
	36	+
	37	+ # PATCH/PUT /groups/1
	38	+ def update
	39	+ if @group.update(group_params)
	40	+ redirect_to @group, notice: 'Group was successfully updated.'
	41	+ else
	42	+ render :edit
	43	+ end
	44	+ end
	45	+
	46	+ # DELETE /groups/1
	47	+ def destroy
	48	+ @group.destroy
	49	+ redirect_to groups_url, notice: 'Group was successfully destroyed.'
	50	+ end
	51	+
	52	+ def remove_user
	53	+ user = User.find(params[:user_id])
	54	+ @group.users.delete(user)
	55	+ redirect_to group_path(@group), notice: "User #{user.login} was removed from the group #{@group.name}"
	56	+ end
	57	+
	58	+ def add_user
	59	+ user = User.find(params[:user_id])
	60	+ @group.users << user
	61	+ redirect_to group_path(@group), notice: "User #{user.login} was add to the group #{@group.name}"
	62	+ end
	63	+
	64	+ def remove_problem
	65	+ problem = Problem.find(params[:problem_id])
	66	+ @group.problems.delete(problem)
	67	+ redirect_to group_path(@group), notice: "Problem #{problem.name} was removed from the group #{@group.name}"
	68	+ end
	69	+
	70	+ def add_problem
	71	+ problem = Problem.find(params[:problem_id])
	72	+ @group.problems << problem
	73	+ redirect_to group_path(@group), notice: "Problem #{problem.name} was add to the group #{@group.name}"
	74	+ end
	75	+
	76	+ private
	77	+ # Use callbacks to share common setup or constraints between actions.
	78	+ def set_group
	79	+ @group = Group.find(params[:id])
	80	+ end
	81	+
	82	+ # Only allow a trusted parameter "white list" through.
	83	+ def group_params
	84	+ params.require(:group).permit(:name, :description)
	85	+ end
	86	+ end

app/helpers/groups_helper.rb created 644 ¶ +2

@@ -0,0 +1,2
	1	+ module GroupsHelper
	2	+ end

app/models/group.rb created 644 ¶ +5

@@ -0,0 +1,5
	1	+ class Group < ActiveRecord::Base
	2	+ has_and_belongs_to_many :problems
	3	+ has_and_belongs_to_many :users
	4	+ end
	5	+

app/views/contests/edit.html.haml created 644 ¶ +20

@@ -0,0 +1,20
	1	+ %h1 Editing contest
	2	+ = form_for(@contest) do \|f\|
	3	+ = f.error_messages
	4	+ %table
	5	+ %tr
	6	+ %td= f.label :name
	7	+ %td= f.text_field :name
	8	+ %tr
	9	+ %td= f.label :title
	10	+ %td= f.text_field :title
	11	+ %tr
	12	+ %td
	13	+ %td
	14	+ = f.check_box :enabled
	15	+ = f.label :enabled
	16	+ %p
	17	+ = f.submit 'Update'
	18	+ = link_to 'Show', @contest
	19	+ \|
	20	+ = link_to 'Back', contests_path

app/views/contests/index.html.haml created 644 ¶ +27

@@ -0,0 +1,27
	1	+ %h1 Listing contests
	2	+ .infobox
	3	+ %b Go back to:
	4	+ [#{link_to 'contest management', :controller => 'contest_management', :action => 'index'}]
	5	+ %p= link_to 'New contest', new_contest_path, class: 'btn btn-success'
	6	+ %table.table.table-striped
	7	+ %tr
	8	+ %th Name
	9	+ %th Title
	10	+ %th Enabled
	11	+ %th
	12	+ %th
	13	+ %th
	14	+
	15	+ - @contests.each do \|contest\|
	16	+ - @contest = contest
	17	+ %tr
	18	+ -#%td= in_place_editor_field :contest, :name, {}, :rows => 1
	19	+ -#%td= in_place_editor_field :contest, :title, {}, :rows => 1
	20	+ -#%td= in_place_editor_field :contest, :enabled, {}, :rows => 1
	21	+ %td= best_in_place @contest, :name
	22	+ %td= best_in_place @contest, :title
	23	+ %td= best_in_place @contest, :enabled
	24	+ %td= link_to 'Show', contest
	25	+ %td= link_to 'Edit', edit_contest_path(contest)
	26	+ %td= link_to 'Destroy', contest, :confirm => 'Are you sure?', :method => :delete
	27	+ %br/

app/views/contests/new.html.haml created 644 ¶ +18

@@ -0,0 +1,18
	1	+ %h1 New contest
	2	+ = form_for(@contest) do \|f\|
	3	+ = f.error_messages
	4	+ %p
	5	+ = f.label :name
	6	+ %br/
	7	+ = f.text_field :name
	8	+ %p
	9	+ = f.label :title
	10	+ %br/
	11	+ = f.text_field :title
	12	+ %p
	13	+ = f.label :enabled
	14	+ %br/
	15	+ = f.check_box :enabled
	16	+ %p
	17	+ = f.submit 'Create'
	18	+ = link_to 'Back', contests_path

app/views/contests/show.html.haml created 644 ¶ +11

@@ -0,0 +1,11
	1	+ %h1
	2	+ Contest: #{h @contest.title}
	3	+ .infobox
	4	+ %b Go back to:
	5	+ [#{link_to 'contest management', :controller => 'contest_management', :action => 'index'}]
	6	+ %p
	7	+ %b Enabled:
	8	+ = h @contest.enabled
	9	+ = link_to 'Edit', edit_contest_path(@contest)
	10	+ \|
	11	+ = link_to 'Back', contests_path

app/views/groups/_form.html.haml created 644 ¶ +16

@@ -0,0 +1,16
	1	+ = form_for @group do \|f\|
	2	+ - if @group.errors.any?
	3	+ #error_explanation
	4	+ %h2= "#{pluralize(@group.errors.count, "error")} prohibited this group from being saved:"
	5	+ %ul
	6	+ - @group.errors.full_messages.each do \|msg\|
	7	+ %li= msg
	8	+
	9	+ .form-group.field
	10	+ = f.label :name
	11	+ = f.text_field :name, class: 'form-control'
	12	+ .form-group.field
	13	+ = f.label :description
	14	+ = f.text_field :description, class: 'form-control'
	15	+ .form-group.actions
	16	+ = f.submit 'Save', class: 'btn btn-primary'

app/views/groups/edit.html.haml created 644 ¶ +7

@@ -0,0 +1,7
	1	+ %h1 Editing group
	2	+
	3	+ = render 'form'
	4	+
	5	+ = link_to 'Show', @group
	6	+ \\|
	7	+ = link_to 'Back', groups_path

app/views/groups/index.html.haml created 644 ¶ +22

@@ -0,0 +1,22
	1	+ %h1 Groups
	2	+
	3	+ %p
	4	+ = link_to 'New Group', new_group_path, class: 'btn btn-primary'
	5	+ %table.table.table-hover
	6	+ %thead
	7	+ %tr
	8	+ %th Name
	9	+ %th Description
	10	+ %th
	11	+ %th
	12	+
	13	+ %tbody
	14	+ - @groups.each do \|group\|
	15	+ %tr
	16	+ %td= group.name
	17	+ %td= group.description
	18	+ %td= link_to 'View', group, class: 'btn btn-default'
	19	+ %td= link_to 'Destroy', group, :method => :delete, :data => { :confirm => 'Are you sure?' }, class: 'btn btn-danger'
	20	+
	21	+ %br
	22	+

app/views/groups/new.html.haml created 644 ¶ +5

@@ -0,0 +1,5
	1	+ %h1 New group
	2	+
	3	+ = render 'form'
	4	+
	5	+ = link_to 'Back', groups_path

app/views/groups/show.html.haml created 644 ¶ +72

@@ -0,0 +1,72
	1	+ %p
	2	+ %b Name:
	3	+ = @group.name
	4	+ %p
	5	+ %b Description:
	6	+ = @group.description
	7	+
	8	+ %br
	9	+ = link_to 'Edit', edit_group_path(@group)
	10	+ \\|
	11	+ = link_to 'Back', groups_path
	12	+
	13	+ .row
	14	+ %h1 Group details
	15	+ .row
	16	+ .col-md-6
	17	+ .panel.panel-default
	18	+ .panel-heading
	19	+ .panel-title Users in this group
	20	+ .panel-body
	21	+ =form_tag add_user_group_path(@group), class: 'form-inline' do
	22	+ .form-group
	23	+ =label_tag :user_id, "User"
	24	+ =select_tag :user_id, options_from_collection_for_select(User.all,'id','full_name'), class: 'select2'
	25	+ =submit_tag "Add",class: 'btn btn-primary'
	26	+
	27	+
	28	+ %table.table.table-hover
	29	+ %thead
	30	+ %tr
	31	+ %th Login
	32	+ %th Full name
	33	+ %th Remark
	34	+ %th
	35	+
	36	+ %tbody
	37	+ - @group.users.each do \|user\|
	38	+ %tr
	39	+ %td= user.login
	40	+ %td= user.full_name
	41	+ %td= user.remark
	42	+ %td= link_to 'Remove', remove_user_group_path(@group,user), :method => :delete, :data => { :confirm => "Remove #{user.full_name}?" }, class: 'btn btn-danger'
	43	+ .col-md-6
	44	+ .panel.panel-default
	45	+ .panel-heading
	46	+ .panel-title Problems
	47	+ .panel-body
	48	+
	49	+ =form_tag add_problem_group_path(@group), class: 'form-inline' do
	50	+ .form-group
	51	+ =label_tag :problem_id, "Problem"
	52	+ =select_tag :problem_id, options_from_collection_for_select(Problem.all,'id','full_name'), class: 'select2'
	53	+ =submit_tag "Add",class: 'btn btn-primary'
	54	+
	55	+
	56	+ %table.table.table-hover
	57	+ %thead
	58	+ %tr
	59	+ %th name
	60	+ %th Full name
	61	+ %th Full score
	62	+ %th
	63	+
	64	+ %tbody
	65	+ - @group.problems.each do \|problem\|
	66	+ %tr
	67	+ %td= problem.name
	68	+ %td= problem.full_name
	69	+ %td= problem.full_score
	70	+ %td= link_to 'Remove', remove_problem_group_path(@group,problem), :method => :delete, :data => { :confirm => "Remove #{problem.full_name}?" }, class: 'btn btn-danger'
	71	+
	72	+

app/views/user_admin/_form.html.haml created 644 ¶ +31

@@ -0,0 +1,31
	1	+ = error_messages_for 'user'
	2	+ / [form:user]
	3	+ .form-group
	4	+ %label.col-md-2.control-label{for: :login} Login
	5	+ .col-md-4
	6	+ = text_field 'user', 'login', class: 'form-control'
	7	+ .form-group
	8	+ %label.col-md-2.control-label{for: :full_name} Full name
	9	+ .col-md-4
	10	+ = text_field 'user', 'full_name', class: 'form-control'
	11	+ .form-group
	12	+ %label.col-md-2.control-label{for: :password} Password
	13	+ .col-md-4
	14	+ = password_field 'user', 'password', class: 'form-control'
	15	+ .form-group
	16	+ %label.col-md-2.control-label{for: :password_confirmation} Password (confirm)
	17	+ .col-md-4
	18	+ = password_field 'user', 'password_confirmation', class: 'form-control'
	19	+ .form-group
	20	+ %label.col-md-2.control-label{for: :email} E-mail
	21	+ .col-md-4
	22	+ = email_field 'user', 'email', class: 'form-control'
	23	+ .form-group
	24	+ %label.col-md-2.control-label{for: :alias} Alias
	25	+ .col-md-4
	26	+ = text_field 'user', 'alias', class: 'form-control'
	27	+ .form-group
	28	+ %label.col-md-2.control-label{for: :remark} Remark
	29	+ .col-md-4
	30	+ = text_field 'user', 'remark', class: 'form-control'
	31	+ / [eoform:user]

app/views/user_admin/show.html.haml created 644 ¶ +14

@@ -0,0 +1,14
	1	+ %h1 User information
	2	+ - for column in User.content_columns
	3	+ %p
	4	+ %b
	5	+ = column.human_name
	6	+ \:
	7	+ = h @user.send(column.name)
	8	+ %p
	9	+ %strong Group
	10	+ \:
	11	+ = @user.groups.map{ \|x\| link_to(x.name,group_path(x)).html_safe}.join(', ').html_safe
	12	+ = link_to 'Edit', :action => 'edit', :id => @user
	13	+ \|
	14	+ = link_to 'Back', :action => 'index'

db/migrate/20170911091143_create_groups.rb created 644 ¶ +30

@@ -0,0 +1,30
	1	+ class CreateGroups < ActiveRecord::Migration
	2	+
	3	+ def change
	4	+ create_table :groups do \|t\|
	5	+ t.string :name
	6	+ t.string :description
	7	+ end
	8	+
	9	+ create_join_table :groups, :users do \|t\|
	10	+ # t.index [:group_id, :user_id]
	11	+ t.index [:user_id, :group_id]
	12	+ end
	13	+
	14	+ create_join_table :problems, :groups do \|t\|
	15	+ # t.index [:problem_id, :group_id]
	16	+ t.index [:group_id, :problem_id]
	17	+ end
	18	+
	19	+ reversible do \|change\|
	20	+ change.up do
	21	+ GraderConfiguration.where(key: 'system.use_problem_group').first_or_create(value_type: 'boolean', value: 'false',
	22	+ description: 'If true, available problem to the user will be only ones associated with the group of the user');
	23	+ end
	24	+
	25	+ change.down do
	26	+ GraderConfiguration.where(key: 'system.use_problem_group').destroy_all
	27	+ end
	28	+ end
	29	+ end
	30	+ end

test/controllers/groups_controller_test.rb created 644 ¶ +49

@@ -0,0 +1,49
	1	+ require 'test_helper'
	2	+
	3	+ class GroupsControllerTest < ActionController::TestCase
	4	+ setup do
	5	+ @group = groups(:one)
	6	+ end
	7	+
	8	+ test "should get index" do
	9	+ get :index
	10	+ assert_response :success
	11	+ assert_not_nil assigns(:groups)
	12	+ end
	13	+
	14	+ test "should get new" do
	15	+ get :new
	16	+ assert_response :success
	17	+ end
	18	+
	19	+ test "should create group" do
	20	+ assert_difference('Group.count') do
	21	+ post :create, group: { description: @group.description, name: @group.name }
	22	+ end
	23	+
	24	+ assert_redirected_to group_path(assigns(:group))
	25	+ end
	26	+
	27	+ test "should show group" do
	28	+ get :show, id: @group
	29	+ assert_response :success
	30	+ end
	31	+
	32	+ test "should get edit" do
	33	+ get :edit, id: @group
	34	+ assert_response :success
	35	+ end
	36	+
	37	+ test "should update group" do
	38	+ patch :update, id: @group, group: { description: @group.description, name: @group.name }
	39	+ assert_redirected_to group_path(assigns(:group))
	40	+ end
	41	+
	42	+ test "should destroy group" do
	43	+ assert_difference('Group.count', -1) do
	44	+ delete :destroy, id: @group
	45	+ end
	46	+
	47	+ assert_redirected_to groups_path
	48	+ end
	49	+ end

app/controllers/application_controller.rb ¶ +11 -13

               class ApplicationController < ActionController::Base
                 protect_from_forgery
                 before_filter :current_user
                 SINGLE_USER_MODE_CONF_KEY = 'system.single_user_mode'
                 MULTIPLE_IP_LOGIN_CONF_KEY = 'right.multiple_ip_login'
                 #report and redirect for unauthorized activities
                 def unauthorized_redirect
                   flash[:notice] = 'You are not authorized to view the page you requested'
                   redirect_to :controller => 'main', :action => 'login'
                 end
                 # Returns the current logged-in user (if any).
                 def current_user
                   return nil unless session[:user_id]
                   @current_user ||= User.find(session[:user_id])
                 end
                 def admin_authorization
                   return false unless authenticate
                   user = User.includes(:roles).find(session[:user_id])
                   unless user.admin?
                     unauthorized_redirect
                     return false
                   end
                   return true
                 end
                 def authorization_by_roles(allowed_roles)
                   return false unless authenticate
                   user = User.find(session[:user_id])
                   unless user.roles.detect { |role| allowed_roles.member?(role.name) }
                     unauthorized_redirect
                     return false
                   end
                 end
                 def testcase_authorization
                   #admin always has privileged
-            -     puts "haha"
                   if @current_user.admin?
                     return true
                   end
-            -     puts "hehe"
-            -     puts GraderConfiguration["right.view_testcase"]
                   unauthorized_redirect unless GraderConfiguration["right.view_testcase"]
                 end
                 protected
                 def authenticate
                   unless session[:user_id]
                     flash[:notice] = 'You need to login'
                     if GraderConfiguration[SINGLE_USER_MODE_CONF_KEY]
                       flash[:notice] = 'You need to login but you cannot log in at this time'
                     end
                     redirect_to :controller => 'main', :action => 'login'
                     return false
                   end
+            +
                   # check if run in single user mode
                   if GraderConfiguration[SINGLE_USER_MODE_CONF_KEY]
-            -       user = User.find_by_id(session[:user_id])
+            +       if @current_user==nil or (not @current_user.admin?)
-            -       if user==nil or (not user.admin?)
                       flash[:notice] = 'You cannot log in at this time'
                       redirect_to :controller => 'main', :action => 'login'
                       return false
                     end
-            -       unless user.enabled?
-            -         flash[:notice] = 'Your account is disabled'
-            -         redirect_to :controller => 'main', :action => 'login'
-            -         return false
-            -       end
                     return true
                   end
+            +     # check if the user is enabled
+            +     unless @current_user.enabled? or @current_user.admin?
+            +       flash[:notice] = 'Your account is disabled'
+            +       redirect_to :controller => 'main', :action => 'login'
+            +       return false
+            +     end
+            +
                   if GraderConfiguration.multicontests?
-            -       user = User.find(session[:user_id])
+            +       return true if @current_user.admin?
-            -       return true if user.admin?
                     begin
-            -         if user.contest_stat(true).forced_logout
+            +         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
                 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 (not user.admin? and user.last_ip and 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'
                       puts "CHEAT: user #{user.login} tried to login from '#{request.remote_ip}' while last ip is '#{user.last_ip}' at #{Time.zone.now}"
                       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 authenticate
                   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' or 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 or user.site == nil
                   if user.contest_finished?

app/controllers/problems_controller.rb ¶ +5

                   end
                   redirect_to action: :index
                 end
                 def turn_all_on
                   Problem.where.not(available: true).each do |problem|
                     problem.available = true
                     problem.save
                   end
                   redirect_to action: :index
                 end
                 def stat
                   @problem = Problem.find(params[:id])
                   unless @problem.available or session[:admin]
                     redirect_to :controller => 'main', :action => 'list'
                     return
                   end
                   @submissions = Submission.includes(:user).where(problem_id: params[:id]).order(:user_id,:id)
                   #stat summary
                   range =65
                   @histogram = { data: Array.new(range,0), summary: {} }
                   user = Hash.new(0)
                   @submissions.find_each do |sub|
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     @histogram[:data][d.to_i] += 1 if d < range
                     user[sub.user_id] = [user[sub.user_id], ((sub.try(:points) || 0) >= @problem.full_score) ? 1 : 0].max
                   end
                   @histogram[:summary][:max] = [@histogram[:data].max,1].max
                   @summary = { attempt: user.count, solve: 0 }
                   user.each_value { |v| @summary[:solve] += 1 if v == 1 }
                 end
                 def manage
                   @problems = Problem.order(date_added: :desc)
                 end
                 def do_manage
                   if params.has_key? 'change_date_added'
                     change_date_added
                   elsif params.has_key? 'add_to_contest'
                     add_to_contest
                   elsif params.has_key? 'enable_problem'
                     set_available(true)
                   elsif params.has_key? 'disable_problem'
                     set_available(false)
+            +     elsif params.has_key? 'add_group'
+            +       group = Group.find(params[:group_id])
+            +       get_problems_from_params.each do |p|
+            +         group.problems << p
+            +       end
                   end
                   redirect_to :action => 'manage'
                 end
                 def import
                   @allow_test_pair_import = allow_test_pair_import?
                 end
                 def do_import
                   old_problem = Problem.find_by_name(params[:name])
                   if !allow_test_pair_import? and params.has_key? :import_to_db
                     params.delete :import_to_db
                   end
                   @problem, import_log = Problem.create_from_import_form_params(params,
                                                                                 old_problem)
                   if !@problem.errors.empty?
                     render :action => 'import' and return
                   end
                   if old_problem!=nil
                     flash[:notice] = "The test data has been replaced for problem #{@problem.name}"
                   end
                   @log = import_log
                 end
                 def remove_contest
                   problem = Problem.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if problem!=nil and contest!=nil
                     problem.contests.delete(contest)
                   end
                   redirect_to :action => 'manage'
                 end
                 ##################################
                 protected
                 def allow_test_pair_import?
                   if defined? ALLOW_TEST_PAIR_IMPORT
                     return ALLOW_TEST_PAIR_IMPORT
                   else
                     return false
                   end
                 end
                 def change_date_added
                   problems = get_problems_from_params

app/controllers/user_admin_controller.rb ¶ +7

                   #set up range from param
                   since_id = params.fetch(:since_id, 0).to_i
                   until_id = params.fetch(:until_id, 0).to_i
                   @users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     @problems.each do |p|
                       max_points = 0
                       Submission.find_in_range_by_user_and_problem(u.id,p.id,since_id,until_id).each do |sub|
                         max_points = sub.points if sub and sub.points and (sub.points > max_points)
                       end
                       ustat << [(max_points.to_f*100/p.full_score).round, (max_points>=p.full_score)]
                     end
                     @scorearray << ustat
                   end
                   if params[:commit] == 'download csv' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'max_score.csv'
                   else
                     render template: 'user_admin/user_stat'
                   end
                 end
                 def import
                   if params[:file]==''
                     flash[:notice] = 'Error importing no file'
                     redirect_to :action => 'index' and return
                   end
                   import_from_file(params[:file])
                 end
                 def random_all_passwords
                   users = User.all
                   @prefix = params[:prefix] || ''
                   @non_admin_users = User.find_non_admin_with_prefix(@prefix)
                   @changed = false
                   if request.request_method == 'POST'
                     @non_admin_users.each do |user|
                       password = random_password
                       user.password = password
                       user.password_confirmation = password
                       user.save
                     end
                     @changed = true
                   end
                 end
+            +
                 # contest management
                 def contests
                   @contest, @users = find_contest_and_user_from_contest_id(params[:id])
                   @contests = Contest.enabled
                 end
                 def assign_from_list
                   contest_id = params[:users_contest_id]
                   org_contest, users = find_contest_and_user_from_contest_id(contest_id)
                   contest = Contest.find(params[:new_contest][:id])
                   if !contest
                     flash[:notice] = 'Error: no contest'
                     redirect_to :action => 'contests', :id =>contest_id
                   end
                   note = []
                   users.each do |u|
                     u.contests = [contest]
                     note << u.login
                   end
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     " were successfully reassigned to #{contest.title}."
                   redirect_to :action => 'contests', :id =>contest.id
                 end
                 def add_to_contest
                   user = User.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if user and contest
                     user.contests << contest
                   end
                   redirect_to :action => 'index'
                 end
                 def remove_from_contest
                   user = User.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if user and contest
                     user.contests.delete(contest)
                   end
                   redirect_to :action => 'index'
                 end
                 def contest_management
                 end
                 def manage_contest
                   if !lines or lines.blank?
                     flash[:notice] = 'You entered an empty list.'
                     redirect_to :action => 'mass_mailing' and return
                   end
                   mail_subject = params[:subject]
                   if !mail_subject or mail_subject.blank?
                     flash[:notice] = 'You entered an empty mail subject.'
                     redirect_to :action => 'mass_mailing' and return
                   end
                   mail_body = params[:email_body]
                   if !mail_body or mail_body.blank?
                     flash[:notice] = 'You entered an empty mail body.'
                     redirect_to :action => 'mass_mailing' and return
                   end
                   note = []
                   users = []
                   lines.split("\n").each do |line|
                     user = User.find_by_login(line.chomp)
                     if user
                       send_mail(user.email, mail_subject, mail_body)
                       note << user.login
                     end
                   end
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     ' were successfully modified.  '
                   redirect_to :action => 'mass_mailing'
                 end
                 #bulk manage
                 def bulk_manage
                   begin
                     @users = User.where('login REGEXP ?',params[:regex]) if params[:regex]
                     @users.count if @users #i don't know why I have to call count, but if I won't exception is not raised
                   rescue Exception
                     flash[:error] = 'Regular Expression is malformed'
                     @users = nil
                   end
                   if params[:commit]
                     @action = {}
                     @action[:set_enable] = params[:enabled]
                     @action[:enabled] = params[:enable] == "1"
                     @action[:gen_password] = params[:gen_password]
+            +       @action[:add_group] = params[:add_group]
+            +       @action[:group_name] = params[:group_name]
                   end
                   if params[:commit] == "Perform"
                     if @action[:set_enable]
                       @users.update_all(enabled: @action[:enabled])
                     end
                     if @action[:gen_password]
                       @users.each do |u|
                         password = random_password
                         u.password = password
                         u.password_confirmation = password
                         u.save
                       end
                     end
+            +       if @action[:add_group] and @action[:group_name]
+            +         @group = Group.find(@action[:group_name])
+            +         @users.each { |user|  @group.users << user }
+            +       end
                   end
                 end
                 protected
                 def random_password(length=5)
                   chars = 'abcdefghijkmnopqrstuvwxyz23456789'
                   newpass = ""
                   length.times { newpass << chars[rand(chars.size-1)] }
                   return newpass
                 end
                 def import_from_file(f)
                   data_hash = YAML.load(f)
                   @import_log = ""
                   country_data = data_hash[:countries]
                   site_data = data_hash[:sites]
                   user_data = data_hash[:users]
                   # import country
                   countries = {}
                   country_data.each_pair do |id,country|
                     c = Country.find_by_name(country[:name])
                     if c!=nil
                       countries[id] = c
                       @import_log << "Found #{country[:name]}\n"
                     else
                       countries[id] = Country.new(:name => country[:name])
                       countries[id].save
                       @import_log << "Created #{country[:name]}\n"
                     end
                   end
                   # import sites
                   sites = {}
                   site_data.each_pair do |id,site|
                     s = Site.find_by_name(site[:name])
                     if s!=nil
                       @import_log << "Found #{site[:name]}\n"
                     else
                       s = Site.new(:name => site[:name])
                       @import_log << "Created #{site[:name]}\n"
                     end
                     s.password = site[:password]
                     s.country = countries[site[:country_id]]
                     s.save
                     sites[id] = s

app/models/grader_configuration.rb ¶ +5

               require 'yaml'
               #
               # This class also contains various login of the system.
               #
               class GraderConfiguration < ActiveRecord::Base
                 SYSTEM_MODE_CONF_KEY = 'system.mode'
                 TEST_REQUEST_EARLY_TIMEOUT_KEY = 'contest.test_request.early_timeout'
                 MULTICONTESTS_KEY = 'system.multicontests'
                 CONTEST_TIME_LIMIT_KEY = 'contest.time_limit'
                 MULTIPLE_IP_LOGIN_KEY = 'right.multiple_ip_login'
                 VIEW_TESTCASE = 'right.view_testcase'
                 SINGLE_USER_KEY = 'system.single_user_mode'
+            +   SYSTEM_USE_PROBLEM_GROUP = 'system.use_problem_group'
                 cattr_accessor :config_cache
                 cattr_accessor :task_grading_info_cache
                 cattr_accessor :contest_time_str
                 cattr_accessor :contest_time
                 GraderConfiguration.config_cache = nil
                 GraderConfiguration.task_grading_info_cache = nil
                 def self.config_cached?
                   (defined? CONFIGURATION_CACHE_ENABLED) and (CONFIGURATION_CACHE_ENABLED)
                 end
                 def self.get(key)
                   if GraderConfiguration.config_cached?
                     if GraderConfiguration.config_cache == nil
                       self.read_config
                     end
                     return GraderConfiguration.config_cache[key]
                   else
                     return GraderConfiguration.read_one_key(key)
                   end
                 end
                 def self.[](key)
                   self.get(key)
                 end
                 def self.reload
                   self.read_config
                 end
                 def self.clear
                   GraderConfiguration.config_cache = nil
                 end
                 #
                 # View decision
                 #
                 def self.show_submitbox_to?(user)
                   mode = get(SYSTEM_MODE_CONF_KEY)
                   return false if mode=='analysis'
                   if (mode=='contest')
                     return false if (user.site!=nil) and
                       ((user.site.started!=true) or (user.site.finished?))
                   end
                   return true
                 end
                 def  self.show_testcase
                   return get(VIEW_TESTCASE)
                 end
                 def self.allow_test_request(user)
                   mode = get(SYSTEM_MODE_CONF_KEY)
                   early_timeout = get(TEST_REQUEST_EARLY_TIMEOUT_KEY)
                   if (mode=='contest')
                     return false if ((user.site!=nil) and
                       ((user.site.started!=true) or
                        (early_timeout and (user.site.time_left < 30.minutes))))
                   end
                   return false if mode=='analysis'
                   return true
                 end
                 def self.task_grading_info
                   if GraderConfiguration.task_grading_info_cache==nil
                     read_grading_info
                   end
                   return GraderConfiguration.task_grading_info_cache
                 end
                 def self.standard_mode?
                   return get(SYSTEM_MODE_CONF_KEY) == 'standard'
                 end
                 def self.contest_mode?
                   return get(SYSTEM_MODE_CONF_KEY) == 'contest'
                 end
                 def self.indv_contest_mode?
                   return get(SYSTEM_MODE_CONF_KEY) == 'indv-contest'
                 end
                 def self.multicontests?
                   return get(MULTICONTESTS_KEY) == true
                 end
                 def self.time_limit_mode?
                   mode = get(SYSTEM_MODE_CONF_KEY)
                   return ((mode == 'contest') or (mode == 'indv-contest'))
                 end
                 def self.analysis_mode?
                   return get(SYSTEM_MODE_CONF_KEY) == 'analysis'
                 end
+            +   def self.use_problem_group?
+            +     return get(SYSTEM_USE_PROBLEM_GROUP)
+            +   end
+            +
                 def self.contest_time_limit
                   contest_time_str = GraderConfiguration[CONTEST_TIME_LIMIT_KEY]
                   if not defined? GraderConfiguration.contest_time_str
                     GraderConfiguration.contest_time_str = nil
                   end
                   if GraderConfiguration.contest_time_str != contest_time_str
                     GraderConfiguration.contest_time_str = contest_time_str
                     if tmatch = /(\d+):(\d+)/.match(contest_time_str)
                       h = tmatch[1].to_i
                       m = tmatch[2].to_i
                       GraderConfiguration.contest_time = h.hour + m.minute
                     else
                       GraderConfiguration.contest_time = nil
                     end
                   end
                   return GraderConfiguration.contest_time
                 end
                 protected
                 def self.convert_type(val,type)
                   case type
                   when 'string'
                     return val
                   when 'integer'
                     return val.to_i
                   when 'boolean'
                     return (val=='true')
                   end
                 end
                 def self.read_config
                   GraderConfiguration.config_cache = {}
                   GraderConfiguration.all.each do |conf|
                     key = conf.key
                     val = conf.value
                     GraderConfiguration.config_cache[key] = GraderConfiguration.convert_type(val,conf.value_type)
                   end
                 end
                 def self.read_one_key(key)
                   conf = GraderConfiguration.find_by_key(key)
                   if conf

app/models/problem.rb ¶ +1

               class Problem < ActiveRecord::Base
                 belongs_to :description
                 has_and_belongs_to_many :contests, :uniq => true
+            +   has_and_belongs_to_many :groups
                 has_many :test_pairs, :dependent => :delete_all
                 has_many :testcases, :dependent => :destroy
                 validates_presence_of :name
                 validates_format_of :name, :with => /\A\w+\z/
                 validates_presence_of :full_name
                 scope :available, -> { where(available: true) }
                 DEFAULT_TIME_LIMIT = 1
                 DEFAULT_MEMORY_LIMIT = 32
                 def self.available_problems
                   available.order(date_added: :desc).order(:name)
                   #Problem.available.all(:order => "date_added DESC, name ASC")
                 end
                 def self.create_from_import_form_params(params, old_problem=nil)
                   org_problem = old_problem || Problem.new
                   import_params, problem = Problem.extract_params_and_check(params,
                                                                             org_problem)
                   if !problem.errors.empty?
                     return problem, 'Error importing'
                   end
                   problem.full_score = 100
                   problem.date_added = Time.new
                   problem.test_allowed = true
                   problem.output_only = false
                   problem.available = false
                   if not problem.save
                     return problem, 'Error importing'
                   end
                   import_to_db = params.has_key? :import_to_db
                   importer = TestdataImporter.new(problem)
                   if not importer.import_from_file(import_params[:file],
                                                    import_params[:time_limit],
                                                    import_params[:memory_limit],
                                                    import_params[:checker_name],
                                                    import_to_db)
                     problem.errors.add(:base,'Import error.')
                   end

app/models/user.rb ¶ +13

               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 :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
                   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
+            +     return problem.uniq
+            +   end
+            +
                 def can_view_problem?(problem)
                   if not GraderConfiguration.multicontests?
                     return problem.available
                   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

app/views/layouts/_header.html.haml ¶ +1

                 %nav
                   .container-fluid
                     .navbar-header
                       %button.navbar-toggle.collapsed{ data: {toggle: 'collapse', target: '#navbar-collapse'} }
                         %span.sr-only Togggle Navigation
                         %span.icon-bar
                         %span.icon-bar
                         %span.icon-bar
                       %a.navbar-brand{href: main_list_path}
                         %span.glyphicon.glyphicon-home
                         MAIN
                     .collapse.navbar-collapse#navbar-collapse
                       %ul.nav.navbar-nav
                         / submission
                         - if (@current_user!=nil) and (GraderConfiguration.show_tasks_to?(@current_user))
                           %li.dropdown
                             %a.dropdown-toggle{href: '#', data: {toggle:'dropdown'},  aria: {haspopup:"true", expanded:"false"}, role: "button"}
                               = "#{I18n.t 'menu.submissions'}"
                               %span.caret
                             %ul.dropdown-menu
                               = add_menu("View", 'submissions', 'index')
                               = add_menu("Self Test", 'test', 'index')
                         / hall of fame
                         - if GraderConfiguration['right.user_hall_of_fame']
                           = add_menu("#{I18n.t 'menu.hall_of_fame'}", 'report', 'problem_hof')
                         / display MODE button (with countdown in contest mode)
                         - if GraderConfiguration.analysis_mode?
                           %div.navbar-btn.btn.btn-success#countdown= "ANALYSIS MODE"
                         - elsif GraderConfiguration.time_limit_mode?
                           - if @current_user.contest_finished?
                             %div.navbar-btn.btn.btn-danger#countdown= "Contest is over"
                           - elsif !@current_user.contest_started?
                             %div.navbar-btn.btn.btn-primary#countdown= (t 'title_bar.contest_not_started')
                           - else
                             %div.navbar-btn.btn.btn-primary#countdown asdf
                             :javascript
                               $("#countdown").countdown({until: "+#{@current_user.contest_time_left.to_i}s", layout: 'Time left: {hnn}:{mnn}:{snn}'});
                         / admin section
                         - if (@current_user!=nil) and (session[:admin])
                           / management
                           %li.dropdown
                             %a.dropdown-toggle{href: '#', data: {toggle:'dropdown'},  aria: {haspopup:"true", expanded:"false"}, role: "button"}
                               Manage
                               %span.caret
                             %ul.dropdown-menu
                               = add_menu( 'Announcements', 'announcements', 'index')
                               = add_menu( 'Problems', 'problems', 'index')
                               = add_menu( 'Users', 'user_admin', 'index')
+            +                 = add_menu( 'User Groups', 'groups', 'index')
                               = add_menu( 'Graders', 'graders', 'list')
                               = add_menu( 'Message ', 'messages', 'console')
                               %li.divider{role: 'separator'}
                               = add_menu( 'System config', 'configurations', 'index')
                               %li.divider{role: 'separator'}
                               = add_menu( 'Sites', 'sites', 'index')
                               = add_menu( 'Contests', 'contest_management', 'index')
                           / report
                           %li.dropdown
                             %a.dropdown-toggle{href: '#', data: {toggle:'dropdown'},  aria: {haspopup:"true", expanded:"false"}, role: "button"}
                               Report
                               %span.caret
                             %ul.dropdown-menu
                               = add_menu( 'Current Score', 'report', 'current_score')
                               = add_menu( 'Score Report', 'report', 'max_score')
                               = add_menu( 'Report', 'report', 'multiple_login')
                           - if (ungraded = Submission.where('graded_at is null').where('submitted_at < ?', 1.minutes.ago).count) > 0
                             =link_to "#{ungraded} backlogs!",
                               grader_list_path,
                               class: 'navbar-btn btn btn-default btn-warning', data: {toggle: 'tooltip'},title: 'Number of ungraded submission'
                       %ul.nav.navbar-nav.navbar-right
                         = add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-question-sign')}".html_safe, 'main', 'help')
                         = 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']
                           = add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-cog')}".html_safe, 'users', 'index', {title: I18n.t('menu.settings'), data: {toggle: 'tooltip'}})
                         = add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-log-out')} #{@current_user.full_name}".html_safe, 'main', 'login', {title: I18n.t('menu.log_out'), data: {toggle: 'tooltip'}})
               /
                 - if (@current_user!=nil) and (session[:admin])
                   %nav.navbar.navbar-fixed-top.navbar-inverse.secondnavbar
                     .container-fluid
                       .collapse.navbar-collapse
                         %ul.nav.navbar-nav
                           = add_menu( '[Announcements]', 'announcements', 'index')
                           = add_menu( '[Msg console]', 'messages', 'console')
                           = add_menu( '[Problems]', 'problems', 'index')
                           = add_menu( '[Users]', 'user_admin', 'index')
                           = add_menu( '[Results]', 'user_admin', 'user_stat')
                           = add_menu( '[Report]', 'report', 'multiple_login')
                           = add_menu( '[Graders]', 'graders', 'list')
                           = add_menu( '[Contests]', 'contest_management', 'index')
                           = add_menu( '[Sites]', 'sites', 'index')
                           = add_menu( '[System config]', 'configurations', 'index')

app/views/problems/manage.html.haml ¶ +7 -2

               - content_for :head do
                 = stylesheet_link_tag 'problems'
                 = javascript_include_tag 'local_jquery'
               :javascript
                 $(document).ready( function() {
                   function shiftclick(start,stop,value) {
                     $('tr input').each( function(id,input) {
                       var $input=$(input);
                       var iid=parseInt($input.attr('id').split('-')[2]);
                       if(iid>=start&&iid<=stop){
                       $input.prop('checked',value)
                       }
                     });
                   }
                   $('tr input').click( function(e)  {
                     if (e.shiftKey) {
                       stop = parseInt($(this).attr('id').split('-')[2]);
                       var orig_stop = stop
                       if (typeof start !== 'undefined') {
                         if (start > stop) {
                           var tmp = start;
                           start = stop;
                           stop = tmp;
                         }
                         shiftclick(start,stop,$(this).is(':checked') )
                       }
                       start = orig_stop
                     } else {
                       start = parseInt($(this).attr('id').split('-')[2]);
                     }
                   });
                 });
               %h1 Manage problems
               %p= link_to '[Back to problem list]', :action => 'list'
               = form_tag :action=>'do_manage' do
-            -   .submitbox
+            +   .submitbox.panel
                   What do you want to do to the selected problem?
                   %br/
                   (You can shift-click to select a range of problems)
                   %ul
                     %li
                       Change date added to
                       = select_date Date.current, :prefix => 'date_added'
                       &nbsp;&nbsp;&nbsp;
                       = submit_tag 'Change', :name => 'change_date_added'
                     %li
                       Set available to
                       = submit_tag 'True', :name => 'enable_problem'
                       = submit_tag 'False', :name => 'disable_problem'
                     - if GraderConfiguration.multicontests?
                       %li
                         Add to
                         = select("contest","id",Contest.all.collect {|c| [c.title, c.id]})
                         = submit_tag 'Add', :name => 'add_to_contest'
+            +       %li
+            +         Add problems to group
+            +         = select_tag "group_id", options_from_collection_for_select( Group.all, 'id','name',params[:group_name]), id: 'group_name',class: 'select2'
+            +         = submit_tag 'Add', name: 'add_group'
-            -   %table
+            +   %table.table.table-hover
                   %tr{style: "text-align: left;"}
                     %th= check_box_tag 'select_all'
                     %th Name
                     %th Full name
                     %th Available
                     %th Date added
                     - if GraderConfiguration.multicontests?
                       %th Contests
                   - num = 0
                   - for problem in @problems
                     - num += 1
                     %tr{:id => "row-prob-#{problem.id}", :name=> "prob-#{problem.id}"}
                       %td= check_box_tag "prob-#{problem.id}-#{num}"
                       %td= problem.name
                       %td= problem.full_name
                       %td= problem.available
                       %td= problem.date_added
                       - if GraderConfiguration.multicontests?
                         %td
                           - problem.contests.each do |contest|
                             = "(#{contest.name} [#{link_to 'x', :action => 'remove_contest', :id => problem.id, :contest_id => contest.id }])"

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

               %h1 Bulk Manage User
               = form_tag bulk_manage_user_admin_path
               .row
                 .col-md-6
                   .panel.panel-primary
                     .panel-title.panel-heading
                       Filter User
                     .panel-body
                       Filtering users whose login match the following MySQL regex
                       .form-group
                         = label_tag "regex", 'Regex Pattern'
                         = text_field_tag "regex", params[:regex], class: 'form-control'
                       %p
                         Example
                       %ul
                         %li
                           %code root
                           matches every user whose login contains "root"
                         %li
                           %code ^56
                           matches every user whose login starts with "56"
                         %li
                           %code 21$
                           matches every user whose login ends with "21"
                 .col-md-6
                   .panel.panel-primary
                     .panel-title.panel-heading
                       Action
                     .panel-body
                       .row.form-group
                         .col-md-6
                           %label.checkbox-inline
                             = check_box_tag "enabled", true, params[:enabled]
                             Change "Enabled" to
                         .col-md-3
                           %label.radio-inline
                             = radio_button_tag "enable", 1, params[:enable] == '1', id: 'enable-yes'
                             Yes
                         .col-md-3
                           %label.radio-inline
                             = radio_button_tag "enable", 0, params[:enable] == '0', id: 'enable-no'
                             No
                       .row.form-group
                         .col-md-6
                           %label.checkbox-inline
                             = check_box_tag "gen_password", true, params[:gen_password]
                             Generate new random password
+            +         .row.form-group
+            +           .col-md-4
+            +             %label.checkbox-inline
+            +               = check_box_tag "add_group", true, params[:add_group]
+            +               Add users to group
+            +           %label.col-md-3.control-label.text-right Group name
+            +           .col-md-5
+            +             = select_tag "group_name", options_from_collection_for_select( Group.all, 'id','name',params[:group_name]), id: 'group_name',class: 'form-control select2'
+            +
               .row
                 .col-md-12
                   = submit_tag "Preview Result", class: 'btn btn-default'
               - if @users
                 .row
                   .col-md-4
                     - if @action
                       %h2 Confirmation
                       - if @action[:set_enable]
                         .alert.alert-info The following users will be set #{(@action[:enabled] ? 'enable' : 'disable')}.
                       - if @action[:gen_password]
                         .alert.alert-info The password of the following users will be randomly generated.
                 .row
                   .col-md-4
                     = submit_tag "Perform", class: 'btn btn-primary'
                 .row
                   .col-md-12
                     The pattern matches #{@users.count} following users.
                     %br
                     - @users.each do |user|
                       = user.login
                       = ' '
                       = user.full_name
                       = ' '
                       = "(#{user.remark})" if user.remark
                       %br

app/views/user_admin/edit.html.haml ¶ +4 -2

               %h1 Editing user
-            - = form_tag :action => 'update', :id => @user do
+            + = form_tag( {:action => 'update', :id => @user}, {class: 'form-horizontal'}) do
                 = error_messages_for 'user'
                 = render partial: "form"
-            -   = submit_tag "Edit"
+            +   .form-group
+            +     .col-md-offset-2.col-md-4
+            +       = submit_tag "Edit", class: 'btn btn-primary'
               = link_to 'Show', :action => 'show', :id => @user
               |
               = link_to 'Back', :action => 'list'

config/routes.rb ¶ +8

               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'
+            +       post 'add_problem', to: 'groups#add_problem', as: 'add_problem'
+            +       delete 'remove_problem/:problem_id', to: 'groups#remove_problem', as: 'remove_problem'
+            +     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'
                 #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'

db/migrate/011_add_language_ext.rb ¶ +1 -1

               class AddLanguageExt < ActiveRecord::Migration
                 def self.up
                   add_column :languages, :ext, :string, :limit => 10
                   Language.reset_column_information
-            -     langs = Language.find(:all)
+            +     langs = Language.all
                   langs.each do |l|
                     l.ext = l.name
                     l.save
                   end
                 end
                 def self.down
                   remove_column :languages, :ext
                 end
               end

db/migrate/015_add_status_to_tasks.rb ¶ +1 -1

               class AddStatusToTasks < ActiveRecord::Migration
                 def self.up
                   add_column :tasks, :status, :integer
                   add_column :tasks, :updated_at, :datetime
                   Task.reset_column_information
-            -     Task.find(:all).each do |task|
+            +     Task.all.each do |task|
                     task.status_complete
                     task.save
                   end
                 end
                 def self.down
                   remove_column :tasks, :updated_at
                   remove_column :tasks, :status
                 end
               end

db/migrate/018_add_number_to_submissions.rb ¶ +1 -2

               class AddNumberToSubmissions < ActiveRecord::Migration
                 def self.up
                   add_column :submissions, :number, :integer
                   # add number field for all records
                   Submission.reset_column_information
                   last_user_id = nil
                   last_problem_id = nil
                   current_number = 0
-            -     Submission.find(:all,
+            +     Submission.order('user_id, problem_id, submitted_at').each do |submission|
-            -                     :order => 'user_id, problem_id, submitted_at').each do |submission|
                     if submission.user_id==last_user_id and submission.problem_id==last_problem_id
                       current_number += 1
                     else
                       current_number = 1
                     end
                     submission.number = current_number
                     submission.save
                     last_user_id = submission.user_id
                     last_problem_id = submission.problem_id
                   end
                   add_index :submissions, [:user_id, :problem_id, :number], :unique => true
                 end
                 def self.down
                   remove_index :submissions, :column => [:user_id, :problem_id, :number]
                   remove_column :submissions, :number
                 end
               end

db/migrate/025_add_site_to_user_and_add_default_site.rb ¶ +1 -1

               class AddSiteToUserAndAddDefaultSite < ActiveRecord::Migration
                 def self.up
                   default_site = Site.new({:name => 'default',
                                             :started => false})
                   default_site.save!
                   add_column :users, :site_id, :integer
                   User.reset_column_information
-            -     User.find(:all).each do |user|
+            +     User.all.each do |user|
                     class << user
                       def valid?
                         true
                       end
                     end
                     user.site_id = default_site.id
                     user.save
                   end
                 end
                 def self.down
                   remove_column :users, :site_id
                   default_site = Site.find_by_name('default')
                   default_site.destroy if default_site
                 end
               end

db/migrate/028_refactor_problem_body_to_description.rb ¶ +2 -2

               class RefactorProblemBodyToDescription < ActiveRecord::Migration
                 def self.up
                   add_column :problems, :description_id, :integer
                   Problem.reset_column_information
-            -     Problem.find(:all).each do |problem|
+            +     Problem.all.each do |problem|
                     if problem.body!=nil
                       description = Description.new
                       description.body = problem.body
                       description.markdowned = false
                       description.save
                       problem.description_id = description.id
                       problem.save
                     end
                   end
                   remove_column :problems, :body
                 end
                 def self.down
                   add_column :problems, :body, :text
                   Problem.reset_column_information
-            -     Problem.find(:all).each do |problem|
+            +     Problem.all.each do |problem|
                     if problem.description_id != nil
                       problem.body = Description.find(problem.description_id).body
                       problem.save
                     end
                   end
                   remove_column :problems, :description_id
                 end
               end

db/migrate/029_add_test_allowed_to_problems.rb ¶ +1 -1

               class AddTestAllowedToProblems < ActiveRecord::Migration
                 def self.up
                   add_column :problems, :test_allowed, :boolean
                   Problem.reset_column_information
-            -     Problem.find(:all).each do |problem|
+            +     Problem.all.each do |problem|
                     problem.test_allowed = true
                     problem.save
                   end
                 end
                 def self.down
                   remove_column :problems, :test_allowed
                 end
               end

db/migrate/20081204122651_add_activated_to_users.rb ¶ +1 -1

               class AddActivatedToUsers < ActiveRecord::Migration
                 def self.up
                   add_column :users, :activated, :boolean, :default => 0
                   User.reset_column_information
-            -     User.find(:all).each do |user|
+            +     User.all.each do |user|
                     # disable validation
                     class <<user
                       def valid?
                         return true
                       end
                     end
                     user.activated = true
                     user.save
                   end
                 end
                 def self.down
                   remove_column :users, :activated
                 end
               end

db/migrate/20090416235658_add_common_ext_to_languages.rb ¶ +1 -1

               class AddCommonExtToLanguages < ActiveRecord::Migration
                 def self.up
                   # language.common_ext is a comma-separated list of common file
                   # extensions.
                   add_column :languages, :common_ext, :string
                   # updating table information
                   Language.reset_column_information
                   common_ext = {
                     'c' => 'c',
                     'cpp' => 'cpp,cc',
                     'pas' => 'pas'
                   }
-            -     Language.find(:all).each do |lang|
+            +     Language.all.each do |lang|
                     lang.common_ext = common_ext[lang.name]
                     lang.save
                   end
                 end
                 def self.down
                   remove_column :languages, :common_ext
                 end
               end

db/schema.rb ¶ +20 -1

               # encoding: UTF-8
               # This file is auto-generated from the current state of the database. Instead
               # of editing this file, please use the migrations feature of Active Record to
               # incrementally modify your database, and then regenerate this schema definition.
               #
               # Note that this schema.rb definition is the authoritative source for your
               # database schema. If you need to create the application database on another
               # system, you should be using db:schema:load, not running all the migrations
               # from scratch. The latter is a flawed and unsustainable approach (the more migrations
               # you'll amass, the slower it'll run and the greater likelihood for issues).
               #
               # It's strongly recommended that you check this file into your version control system.
-            - ActiveRecord::Schema.define(version: 20170427070345) do
+            + ActiveRecord::Schema.define(version: 20170911091143) do
                 create_table "announcements", force: :cascade do |t|
                   t.string   "author",       limit: 255
                   t.text     "body",         limit: 16777215
                   t.boolean  "published"
                   t.datetime "created_at",                                    null: false
                   t.datetime "updated_at",                                    null: false
                   t.boolean  "frontpage",                     default: false
                   t.boolean  "contest_only",                  default: false
                   t.string   "title",        limit: 255
                   t.string   "notes",        limit: 255
                 end
                 create_table "contests", force: :cascade do |t|
                   t.string   "title",      limit: 255
                   t.boolean  "enabled"
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                   t.string   "name",       limit: 255
                 end
                 create_table "contests_problems", id: false, force: :cascade do |t|
                   t.integer "contest_id", limit: 4
                   t.integer "problem_id", limit: 4
                 end
                 create_table "contests_users", id: false, force: :cascade do |t|
                   t.integer "contest_id", limit: 4
                   t.integer "user_id",    limit: 4
                 end
                 create_table "countries", force: :cascade do |t|
                   t.string   "name",       limit: 255
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                 end
                 create_table "descriptions", force: :cascade do |t|
                   t.text     "body",       limit: 16777215
                   t.boolean  "markdowned"
                   t.datetime "created_at",                  null: false
                   t.datetime "updated_at",                  null: false
                 end
                 create_table "grader_configurations", force: :cascade do |t|
                   t.string   "key",         limit: 255
                   t.string   "value_type",  limit: 255
                   t.string   "value",       limit: 255
                   t.datetime "created_at",                   null: false
                   t.datetime "updated_at",                   null: false
                   t.text     "description", limit: 16777215
                 end
                 create_table "grader_processes", force: :cascade do |t|
                   t.string   "host",       limit: 255
                   t.integer  "pid",        limit: 4
                   t.string   "mode",       limit: 255
                   t.boolean  "active"
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                   t.integer  "task_id",    limit: 4
                   t.string   "task_type",  limit: 255
                   t.boolean  "terminated"
                 end
                 add_index "grader_processes", ["host", "pid"], name: "index_grader_processes_on_ip_and_pid", using: :btree
+            +   create_table "groups", force: :cascade do |t|
+            +     t.string "name",        limit: 255
+            +     t.string "description", limit: 255
+            +   end
+            +
+            +   create_table "groups_problems", id: false, force: :cascade do |t|
+            +     t.integer "problem_id", limit: 4, null: false
+            +     t.integer "group_id",   limit: 4, null: false
+            +   end
+            +
+            +   add_index "groups_problems", ["group_id", "problem_id"], name: "index_groups_problems_on_group_id_and_problem_id", using: :btree
+            +
+            +   create_table "groups_users", id: false, force: :cascade do |t|
+            +     t.integer "group_id", limit: 4, null: false
+            +     t.integer "user_id",  limit: 4, null: false
+            +   end
+            +
+            +   add_index "groups_users", ["user_id", "group_id"], name: "index_groups_users_on_user_id_and_group_id", using: :btree
+            +
                 create_table "heart_beats", force: :cascade do |t|
                   t.integer  "user_id",    limit: 4
                   t.string   "ip_address", limit: 255
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                   t.string   "status",     limit: 255
                 end
                 add_index "heart_beats", ["updated_at"], name: "index_heart_beats_on_updated_at", using: :btree
                 create_table "languages", force: :cascade do |t|
                   t.string "name",        limit: 10
                   t.string "pretty_name", limit: 255
                   t.string "ext",         limit: 10
                   t.string "common_ext",  limit: 255
                 end
                 create_table "logins", force: :cascade do |t|
                   t.integer  "user_id",    limit: 4
                   t.string   "ip_address", limit: 255
                   t.datetime "created_at",             null: false
                   t.datetime "updated_at",             null: false
                 end
                 create_table "messages", force: :cascade do |t|
                   t.integer  "sender_id",           limit: 4
                   t.integer  "receiver_id",         limit: 4
                   t.integer  "replying_message_id", limit: 4
                   t.text     "body",                limit: 16777215
                   t.boolean  "replied"
                   t.datetime "created_at",                           null: false
                   t.datetime "updated_at",                           null: false
                 end
                 create_table "problems", force: :cascade do |t|
                   t.string  "name",                 limit: 30
                   t.string  "full_name",            limit: 255
                   t.integer "full_score",           limit: 4
                   t.date    "date_added"
                   t.boolean "available"
                   t.string  "url",                  limit: 255
                   t.integer "description_id",       limit: 4
                   t.boolean "test_allowed"
                   t.boolean "output_only"
                   t.string  "description_filename", limit: 255
                   t.boolean "view_testcase"
                 end

db/seeds.rb ¶ +10 -1

                  },
                  {
                    :key => 'system.admin_email',
                    :value_type => 'string',
                    :default_value => 'admin@admin.email'
                  },
                  {
                    :key => 'system.user_setting_enabled',
                    :value_type => 'boolean',
                    :default_value => 'true',
                    :description => 'If this option is true, users can change their settings'
                  },
                  {
                    :key => 'system.user_setting_enabled',
                    :value_type => 'boolean',
                    :default_value => 'true',
                    :description => 'If this option is true, users can change their settings'
                  },
                  # If Configuration['contest.test_request.early_timeout'] is true
                  # the user will not be able to use test request at 30 minutes
                  # before the contest ends.
                  {
                    :key => 'contest.test_request.early_timeout',
                    :value_type => 'boolean',
                    :default_value => 'false'
                  },
                  {
                    :key => 'system.multicontests',
                    :value_type => 'boolean',
                    :default_value => 'false'
                  },
                  {
                    :key => 'contest.confirm_indv_contest_start',
                    :value_type => 'boolean',
                    :default_value => 'false'
                  },
                  {
                    :key => 'contest.default_contest_name',
                    :value_type => 'string',
                    :default_value => 'none',
                    :description => "New user will be assigned to this contest automatically, if it exists.  Set to 'none' if there is no default contest."
-            -    }
+            +    },
+            +
+            +    {
+            +      :key => 'system.use_problem_group',
+            +      :value_type => 'boolean',
+            +      :default_value => 'false',
+            +      :description => "If true, available problem to the user will be only ones associated with the group of the user."
+            +    },
+            +
+            +
                 ]
               def create_configuration_key(key,
                                            value_type,
                                            default_value,
                                            description='')
                 conf = (GraderConfiguration.find_by_key(key) ||
                         GraderConfiguration.new(:key => key,
                                           :value_type => value_type,
                                           :value => default_value))
                 conf.description = description
                 conf.save
               end
               def seed_config
                 CONFIGURATIONS.each do |conf|
                   if conf.has_key? :description
                     desc = conf[:description]
                   else
                     desc = ''
                   end
                   create_configuration_key(conf[:key],
                                            conf[:value_type],
                                            conf[:default_value],
                                            desc)
                 end
               end
               def seed_roles
                 return if Role.find_by_name('admin')
                 role = Role.create(:name => 'admin')
                 user_admin_right = Right.create(:name => 'user_admin',
                                                 :controller => 'user_admin',
                                                 :action => 'all')
                 problem_admin_right = Right.create(:name=> 'problem_admin',
                                                    :controller => 'problems',
                                                    :action => 'all')
                 graders_right = Right.create(:name => 'graders_admin',
                                              :controller => 'graders',
                                              :action => 'all')
                 role.rights << user_admin_right;
                 role.rights << problem_admin_right;
                 role.rights << graders_right;

app/views/contests/edit.html.erb removed ¶ -29

deleted file

app/views/contests/index.html.erb removed ¶ -29

deleted file

app/views/contests/new.html.erb removed ¶ -23

deleted file

app/views/contests/show.html.erb removed ¶ -14

deleted file

app/views/user_admin/_form.html.erb removed ¶ -25

deleted file

app/views/user_admin/show.html.erb removed ¶ -10

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

r685:101d67319b73 - Mon, 11 Sep 2017 15:59:08 - 43 files changed: 525 inserted, 159 deleted

Sign in to your account

Commit r685:101d67319b73 public

Author

r685:101d67319b73 - Mon, 11 Sep 2017 15:59:08 - 43 files changed: 525 inserted, 159 deleted

Commit `r685:101d67319b73` public