cafe-grader-web Commit - r526:f7b4a30e2f5d

cafe-grader-web

Commit `r526:f7b4a30e2f5d` public

parent | child

Description:

merge with algo-bm, take cheat report

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

r526:f7b4a30e2f5d - Tue, 11 Aug 2015 11:28:41 - 12 files changed: 252 inserted, 6 deleted

app/views/report/cheat_report.html.haml created 644 ¶ +77

@@ -0,0 +1,77
	1	+ - content_for :header do
	2	+ = stylesheet_link_tag 'tablesorter-theme.cafe'
	3	+ = javascript_include_tag 'local_jquery'
	4	+
	5	+ %script{:type=>"text/javascript"}
	6	+ $(function () {
	7	+ $('#since_datetime').datetimepicker({ showButtonPanel: true, dateFormat: "yy-mm-dd", controlType: "slider"} );
	8	+ $('#until_datetime').datetimepicker({ showButtonPanel: true, dateFormat: "yy-mm-dd", controlType: "slider"} );
	9	+ $('#my_table').tablesorter({widthFixed: true, widgets: ['zebra']});
	10	+ $('#my_table2').tablesorter({widthFixed: true, widgets: ['zebra']});
	11	+ $('#sub_table').tablesorter({widthFixed: true, widgets: ['zebra']});
	12	+ });
	13	+
	14	+ %h1 Login status
	15	+
	16	+ =render partial: 'report_menu'
	17	+ =render partial: 'date_range', locals: {param_text: 'Login date range:', title: 'Query login stat in the range' }
	18	+
	19	+ %h2 Suspect
	20	+
	21	+ %table.tablesorter-cafe#my_table
	22	+ %thead
	23	+ %tr
	24	+ %th login
	25	+ %th full name
	26	+ %th login count
	27	+ %tbody
	28	+ - @ml.each do \|l\|
	29	+ %tr{class: cycle('info-even','info-odd')}
	30	+ %td= link_to l[:login], controller: 'users', action: 'profile', id: l[:id]
	31	+ %td= l[:full_name]
	32	+ %td= l[:count]
	33	+
	34	+
	35	+ %h2 Multiple Logins Report
	36	+ This section reports all logins record that have either multiple ip per login or multiple login per ip.
	37	+
	38	+ %table.tablesorter-cafe#my_table2
	39	+ %thead
	40	+ %tr
	41	+ %th login
	42	+ %th full name
	43	+ %th IP
	44	+ %th time
	45	+ %tbody
	46	+ - @mld.each do \|l\|
	47	+ %tr{class: cycle('info-even','info-odd')}
	48	+ %td= link_to l.user[:login], controller: 'users', action: 'profile', id: l[:user_id]
	49	+ %td= l.user[:full_name]
	50	+ %td= l[:ip_address]
	51	+ %td= l[:created_at]
	52	+
	53	+ %h2 Multiple IP Submissions Report
	54	+ This section reports all submission records that have USER_ID matchs ID that logins on multiple IP
	55	+ and that have IP_ADDRESS that has multiple ID logins
	56	+
	57	+ Be noted that when submission IP address is not available, this might exclude
	58	+ submissions that come from ID that login on multiple-login IP
	59	+
	60	+ %table.tablesorter-cafe#sub_table
	61	+ %thead
	62	+ %tr
	63	+ %th login
	64	+ %th full name
	65	+ %th IP
	66	+ %th problem
	67	+ %th Submission
	68	+ %th time
	69	+ %tbody
	70	+ - @subs.each do \|s\|
	71	+ %tr{class: cycle('info-even','info-odd')}
	72	+ %td= link_to s.user[:login], controller: 'users', action: 'profile', id: s[:user_id]
	73	+ %td= s.user[:full_name]
	74	+ %td= s[:ip_address]
	75	+ %td= s.problem.name
	76	+ %td= link_to(s.id, controller: 'graders' , action: 'submission', id: s.id)
	77	+ %td= s[:submitted_at]

db/migrate/20150503164846_change_userid_on_login.rb created 644 ¶ +9

@@ -0,0 +1,9
	1	+ class ChangeUseridOnLogin < ActiveRecord::Migration
	2	+ def up
	3	+ change_column :logins, :user_id, :integer
	4	+ end
	5	+
	6	+ def down
	7	+ change_column :logins, :user_id, :string
	8	+ end
	9	+ end

app/controllers/application_controller.rb ¶ +18

               class ApplicationController < ActionController::Base
                 protect_from_forgery
                 SINGLE_USER_MODE_CONF_KEY = 'system.single_user_mode'
+            +   MULTIPLE_IP_LOGIN_CONF_KEY = 'right.multiple_ip_login'
                 def admin_authorization
                   return false unless authenticate
                   user = User.find(session[:user_id], :include => ['roles'])
                   unless user.admin?
                     flash[:notice] = 'You are not authorized to view the page you requested'
                     redirect_to :controller => 'main', :action => 'login' unless user.admin?
                     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) }
                     flash[:notice] = 'You are not authorized to view the page you requested'
                     redirect_to :controller => 'main', :action => 'login'
                     return false
                   end
                 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(session[:user_id])
                     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
                     return true
                   end
                   if GraderConfiguration.multicontests?
                     user = User.find(session[:user_id])
                     return true if user.admin?
                     begin
                       if 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'
+            +         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?
                     flash[:notice] = 'Error: the contest you are participating is over.'
                     redirect_to :back
                     return false
                   end
                   return true
                 end
               end

app/controllers/configurations_controller.rb ¶ +1

               class ConfigurationsController < ApplicationController
                 before_filter :authenticate
                 before_filter { |controller| controller.authorization_by_roles(['admin'])}
                 def index
                   @configurations = GraderConfiguration.find(:all,
                                                        :order => '`key`')
                 end
                 def reload
                   GraderConfiguration.reload
                   redirect_to :action => 'index'
                 end
                 def update
                   @config = GraderConfiguration.find(params[:id])
+            +     User.clear_last_login if @config.key = 'multiple_ip_login' and @config.value == 'true' and params[:grader_configuration][:value] == 'false'
                   respond_to do |format|
                     if @config.update_attributes(params[:grader_configuration])
                       format.json { head :ok }
                     else
                       format.json { respond_with_bip(@config) }
                     end
                   end
                 end
               end

app/controllers/main_controller.rb ¶ +2

               class MainController < ApplicationController
                 before_filter :authenticate, :except => [:index, :login]
                 before_filter :check_viewability, :except => [:index, :login]
                 append_before_filter :confirm_and_update_start_time,
                                      :except => [:index,
                                                  :login,
                                                  :confirm_contest_start]
                 # to prevent log in box to be shown when user logged out of the
                 # system only in some tab
                 prepend_before_filter :reject_announcement_refresh_when_logged_out,
                                       :only => [:announcements]
+            +   before_filter :authenticate_by_ip_address, :only => [:list]
+            +
                 # COMMENTED OUT: filter in each action instead
                 # before_filter :verify_time_limit, :only => [:submit]
                 verify :method => :post, :only => [:submit],
                        :redirect_to => { :action => :index }
                 # COMMENT OUT: only need when having high load
                 # caches_action :index, :login
                 # NOTE: This method is not actually needed, 'config/routes.rb' has
                 # assigned action login as a default action.
                 def index
                   redirect_to :action => 'login'
                 end
                 def login
                   saved_notice = flash[:notice]
                   reset_session
                   flash.now[:notice] = saved_notice
                   # EXPERIMENT:
                   # Hide login if in single user mode and the url does not
                   # explicitly specify /login
                   #
                   # logger.info "PATH: #{request.path}"
                   # if GraderConfiguration['system.single_user_mode'] and
                   #     request.path!='/main/login'
                   #   @hidelogin = true
                   # end
                   @announcements = Announcement.find_for_frontpage
                   render :action => 'login', :layout => 'empty'
                 end
                 def list
                   prepare_list_information
                 end
                 def help
                   @user = User.find(session[:user_id])
                 end
                 def submit
                   user = User.find(session[:user_id])
                   @submission = Submission.new
                   @submission.problem_id = params[:submission][:problem_id]
                   @submission.user = user
                   @submission.language_id = 0
                   if (params['file']) and (params['file']!='')
                     @submission.source = File.open(params['file'].path,'r:UTF-8',&:read)
                     @submission.source.encode!('UTF-8','UTF-8',invalid: :replace, replace: '')
                     @submission.source_filename = params['file'].original_filename
                   end
                   @submission.submitted_at = Time.new.gmtime
                   @submission.ip_address = request.remote_ip
                   if GraderConfiguration.time_limit_mode? and user.contest_finished?
                     @submission.errors.add(:base,"The contest is over.")
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   if @submission.valid?
                     if @submission.save == false
               	flash[:notice] = 'Error saving your submission'
                     elsif Task.create(:submission_id => @submission.id,
                                       :status => Task::STATUS_INQUEUE) == false
               	flash[:notice] = 'Error adding your submission to task queue'
                     end
                   else
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   redirect_to :action => 'list'
                 end
                 def source
                   submission = Submission.find(params[:id])
                   if ((submission.user_id == session[:user_id]) and
                       (submission.problem != nil) and
                       (submission.problem.available))
                     send_data(submission.source,
               		{:filename => submission.download_filename,
                                 :type => 'text/plain'})
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def compiler_msg
                   @submission = Submission.find(params[:id])
                   if @submission.user_id == session[:user_id]
                     render :action => 'compiler_msg', :layout => 'empty'
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def submission
                   @user = User.find(session[:user_id])
                   @problems = @user.available_problems
                   if params[:id]==nil
                     @problem = nil
                     @submissions = nil
                   else
                     @problem = Problem.find_by_name(params[:id])
                     if not @problem.available
                       redirect_to :action => 'list'
                       flash[:notice] = 'Error: submissions for that problem are not viewable.'
                       return
                     end
                     @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id)
                   end
                 end
                 def result
                   if !GraderConfiguration.show_grading_result
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   prepare_grading_result(@submission)
                 end
                 def load_output
                   if !GraderConfiguration.show_grading_result or params[:num]==nil
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   case_num = params[:num].to_i
                   out_filename = output_filename(@user.login,
                                                  @submission.problem.name,
                                                  @submission.id,
                                                  case_num)
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   if defined?(USE_APACHE_XSENDFILE) and USE_APACHE_XSENDFILE
                     response.headers['Content-Type'] = "application/force-download"
                     response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
                     response.headers["X-Sendfile"] = out_filename
                     response.headers['Content-length'] = File.size(out_filename)
                     render :nothing => true
                   else
                     send_file out_filename, :stream => false, :filename => "output-#{case_num}.txt", :type => "text/plain"
                   end
                 end
                 def error
                   @user = User.find(session[:user_id])
                 end
                 # announcement refreshing and hiding methods
                 def announcements
                   if params.has_key? 'recent'
                     prepare_announcements(params[:recent])
                   else
                     prepare_announcements
                   end
                   render(:partial => 'announcement',
                          :collection => @announcements,
                          :locals => {:announcement_effect => true})
                 end
                 def confirm_contest_start
                   user = User.find(session[:user_id])
                   if request.method == 'POST'
                     user.update_start_time
                     redirect_to :action => 'list'
                   else
                     @contests = user.contests
                     @user = user
                   end
                 end
                 protected

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

               class ReportController < ApplicationController
-            -   before_filter :admin_authorization, only: [:login_stat,:submission_stat, :stuck]
+            +   before_filter :admin_authorization, only: [:login_stat,:submission_stat, :stuck, :cheat_report, :cheat_scruntinize]
+            +
                 before_filter(only: [:problem_hof]) { |c|
                   return false unless authenticate
                   if GraderConfiguration["right.user_view_submission"]
                     return true;
                   end
                   admin_authorization
                 }
                 def login_stat
                   @logins = Array.new
                   date_and_time = '%Y-%m-%d %H:%M'
                   begin
                     md = params[:since_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
                     @since_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
                   rescue
                     @since_time = DateTime.new(1000,1,1)
                   end
                   begin
                     md = params[:until_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
                     @until_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
                   rescue
                     @until_time = DateTime.new(3000,1,1)
                   end
                   User.all.each do |user|
                     @logins << { id: user.id,
                                  login: user.login,
                                  full_name: user.full_name,
                                  count: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .count(:id),
                                  min: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .minimum(:created_at),
                                  max: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .maximum(:created_at),
                                   ip: Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
                                                     user.id,@since_time,@until_time)
                                         .select(:ip_address).uniq
                                }
                   end
                 end
                 def submission_stat
                   date_and_time = '%Y-%m-%d %H:%M'
                   begin
                     @since_time = DateTime.strptime(params[:since_datetime],date_and_time)
                   rescue
                     @since_time = DateTime.new(1000,1,1)
                   end
                   begin
                     @until_time = DateTime.strptime(params[:until_datetime],date_and_time)
                   rescue
                     @until_time = DateTime.new(3000,1,1)
                   end
                   @submissions = {}
                   User.find_each do |user|
                     @submissions[user.id] = { login: user.login, full_name: user.full_name, count: 0, sub: { } }
                   end
                   Submission.where("submitted_at >= ? AND submitted_at <= ?",@since_time,@until_time).find_each do |s|
                     if @submissions[s.user_id]
                       if not @submissions[s.user_id][:sub].has_key?(s.problem_id)
                         a = nil
                         begin
                           a = Problem.find(s.problem_id)
                         rescue
                           a = nil
                         end
                         @submissions[s.user_id][:sub][s.problem_id] =
                           { prob_name: (a ? a.full_name : '(NULL)'),
                             sub_ids: [s.id] }
                       else
                         @submissions[s.user_id][:sub][s.problem_id][:sub_ids] << s.id
                       end
                       @submissions[s.user_id][:count] += 1
                     end
                   end
                 end
                 def problem_hof
                   # gen problem list
                   @user = User.find(session[:user_id])
                   @problems = @user.available_problems
                   # get selected problems or the default
                   if params[:id]
                     begin
                       @problem = Problem.available.find(params[:id])
                     rescue
                       redirect_to action: :problem_hof
                       flash[:notice] = 'Error: submissions for that problem are not viewable.'
                       return
                     end
                   end
                   return unless @problem
                   @by_lang = {} #aggregrate by language
                   range =65
                   @histogram = { data: Array.new(range,0), summary: {} }
                   @summary = {count: 0, solve: 0, attempt: 0}
                   user = Hash.new(0)
                   Submission.where(problem_id: @problem.id).find_each do |sub|
                     #histogram
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     @histogram[:data][d.to_i] += 1 if d < range
                     next unless sub.points
                     @summary[:count] += 1
                     user[sub.user_id] = [user[sub.user_id], (sub.points >= @problem.full_score) ? 1 : 0].max
                     lang = Language.find_by_id(sub.language_id)
                     next unless lang
                     next unless sub.points >= @problem.full_score
                     #initialize
                     unless @by_lang.has_key?(lang.pretty_name)
                       @by_lang[lang.pretty_name] = {
                         runtime: { avail: false, value: 2**30-1 },
                         memory: { avail: false, value: 2**30-1 },
                         length: { avail: false, value: 2**30-1 },
                         first: { avail: false, value: DateTime.new(3000,1,1) }
                       }
                     end
                     if sub.max_runtime and sub.max_runtime < @by_lang[lang.pretty_name][:runtime][:value]
                       @by_lang[lang.pretty_name][:runtime] = { avail: true, user_id: sub.user_id, value: sub.max_runtime, sub_id: sub.id }
                     end
                     if sub.peak_memory and sub.peak_memory < @by_lang[lang.pretty_name][:memory][:value]
                       @by_lang[lang.pretty_name][:memory] = { avail: true, user_id: sub.user_id, value: sub.peak_memory, sub_id: sub.id }
                     end
                     if sub.submitted_at and sub.submitted_at < @by_lang[lang.pretty_name][:first][:value] and
                         !sub.user.admin?
                       @by_lang[lang.pretty_name][:first] = { avail: true, user_id: sub.user_id, value: sub.submitted_at, sub_id: sub.id }
                     end
                     if @by_lang[lang.pretty_name][:length][:value] > sub.effective_code_length
                       @by_lang[lang.pretty_name][:length] = { avail: true, user_id: sub.user_id, value: sub.effective_code_length, sub_id: sub.id }
                     end
                   end
                   #process user_id
                   @by_lang.each do |lang,prop|
                     prop.each do |k,v|
                       v[:user] = User.exists?(v[:user_id]) ? User.find(v[:user_id]).full_name : "(NULL)"
                     end
                   end
                   #sum into best
                   if @by_lang and @by_lang.first
                     @best = @by_lang.first[1].clone
                     @by_lang.each do |lang,prop|
                       if @best[:runtime][:value] >= prop[:runtime][:value]
                         @best[:runtime] = prop[:runtime]
                         @best[:runtime][:lang] = lang
                       end
                       if @best[:memory][:value] >= prop[:memory][:value]
                         @best[:memory] = prop[:memory]
                         @best[:memory][:lang] = lang
                       end
                       if @best[:length][:value] >= prop[:length][:value]
                         @best[:length] = prop[:length]
                         @best[:length][:lang] = lang
                       end
                       if @best[:first][:value] >= prop[:first][:value]
                         @best[:first] = prop[:first]
                         @best[:first][:lang] = lang
                       end
                     end
                   end
                   @histogram[:summary][:max] = [@histogram[:data].max,1].max
                   @summary[:attempt] = user.count
                   user.each_value { |v| @summary[:solve] += 1 if v == 1 }
                 end
                 def stuck #report struggling user,problem
                   # init
                   user,problem = nil
                   solve = true
                   tries = 0
                   @struggle = Array.new
                   record = {}
                   Submission.includes(:problem,:user).order(:problem_id,:user_id).find_each do |sub|
                     next unless sub.problem and sub.user
                     if user != sub.user_id or problem != sub.problem_id
                       @struggle << { user: record[:user], problem: record[:problem], tries: tries } unless solve
                       record = {user: sub.user, problem: sub.problem}
                       user,problem = sub.user_id, sub.problem_id
                       solve = false
                       tries = 0
                     end
                     if sub.points >= sub.problem.full_score
                       solve = true
                     else
                       tries += 1
                     end
                   end
                   @struggle.sort!{|a,b| b[:tries] <=> a[:tries] }
                   @struggle = @struggle[0..50]
                 end
                 def multiple_login
                   #user with multiple IP
                   raw = Submission.joins(:user).joins(:problem).where("problems.available != 0").group("login,ip_address").order(:login)
                   last,count = 0,0
                   first = 0
                   @users = []
                   raw.each do |r|
                     if last != r.user.login
                       count = 1
                       last = r.user.login
                       first = r
                     else
                       @users << first if count == 1
                       @users << r
                       count += 1
                     end
                   end
                   #IP with multiple user
                   raw = Submission.joins(:user).joins(:problem).where("problems.available != 0").group("login,ip_address").order(:ip_address)
                   last,count = 0,0
                   first = 0
                   @ip = []
                   raw.each do |r|
                     if last != r.ip_address
                       count = 1
                       last = r.ip_address
                       first = r
                     else
                       @ip << first if count == 1
                       @ip << r
                       count += 1
                     end
                   end
                 end
+            +   def cheat_report
+            +     date_and_time = '%Y-%m-%d %H:%M'
+            +     begin
+            +       md = params[:since_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
+            +       @since_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
+            +     rescue
+            +       @since_time = Time.zone.now.ago( 90.minutes)
                   end
+            +     begin
+            +       md = params[:until_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
+            +       @until_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
+            +     rescue
+            +       @until_time = Time.zone.now
+            +     end
+            +
+            +     #multi login
+            +     @ml = Login.joins(:user).where("logins.created_at >= ? and logins.created_at <= ?",@since_time,@until_time).select('users.login,count(distinct ip_address) as count,users.full_name').group("users.id").having("count > 1")
+            +
+            +     st = <<-SQL
+            +   SELECT l2.*
+            +     FROM logins l2 INNER JOIN
+            +     (SELECT u.id,COUNT(DISTINCT ip_address) as count,u.login,u.full_name
+            +       FROM logins l
+            +       INNER JOIN users u ON l.user_id =  u.id
+            +       WHERE l.created_at >= '#{@since_time.in_time_zone("UTC")}' and l.created_at <= '#{@until_time.in_time_zone("UTC")}'
+            +       GROUP BY u.id
+            +       HAVING count > 1
+            +     ) ml ON l2.user_id = ml.id
+            +     WHERE l2.created_at >= '#{@since_time.in_time_zone("UTC")}' and l2.created_at <= '#{@until_time.in_time_zone("UTC")}'
+            + UNION
+            +   SELECT l2.*
+            +     FROM logins l2 INNER JOIN
+            +     (SELECT l.ip_address,COUNT(DISTINCT u.id) as count
+            +       FROM logins l
+            +       INNER JOIN users u ON l.user_id =  u.id
+            +       WHERE l.created_at >= '#{@since_time.in_time_zone("UTC")}' and l.created_at <= '#{@until_time.in_time_zone("UTC")}'
+            +       GROUP BY l.ip_address
+            +       HAVING count > 1
+            +     ) ml on ml.ip_address = l2.ip_address
+            +     INNER JOIN users u ON l2.user_id = u.id
+            +     WHERE l2.created_at >= '#{@since_time.in_time_zone("UTC")}' and l2.created_at <= '#{@until_time.in_time_zone("UTC")}'
+            + ORDER BY ip_address,created_at
+            +               SQL
+            +     @mld = Login.find_by_sql(st)
+            +
+            +     st = <<-SQL
+            +   SELECT s.id,s.user_id,s.ip_address,s.submitted_at,s.problem_id
+            +     FROM submissions s INNER JOIN
+            +     (SELECT u.id,COUNT(DISTINCT ip_address) as count,u.login,u.full_name
+            +       FROM logins l
+            +       INNER JOIN users u ON l.user_id =  u.id
+            +       WHERE l.created_at >= ? and l.created_at <= ?
+            +       GROUP BY u.id
+            +       HAVING count > 1
+            +     ) ml ON s.user_id = ml.id
+            +     WHERE s.submitted_at >= ? and s.submitted_at <= ?
+            + UNION
+            +   SELECT s.id,s.user_id,s.ip_address,s.submitted_at,s.problem_id
+            +     FROM submissions s INNER JOIN
+            +     (SELECT l.ip_address,COUNT(DISTINCT u.id) as count
+            +       FROM logins l
+            +       INNER JOIN users u ON l.user_id =  u.id
+            +       WHERE l.created_at >= ? and l.created_at <= ?
+            +       GROUP BY l.ip_address
+            +       HAVING count > 1
+            +     ) ml on ml.ip_address = s.ip_address
+            +     WHERE s.submitted_at >= ? and s.submitted_at <= ?
+            + ORDER BY ip_address,submitted_at
+            +             SQL
+            +     @subs = Submission.joins(:problem).find_by_sql([st,@since_time,@until_time,
+            +                                        @since_time,@until_time,
+            +                                        @since_time,@until_time,
+            +                                        @since_time,@until_time])
+            +
+            +   end
+            +
+            +   def cheat_scruntinize
+            +     #convert date & time
+            +     date_and_time = '%Y-%m-%d %H:%M'
+            +     begin
+            +       md = params[:since_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
+            +       @since_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
+            +     rescue
+            +       @since_time = Time.zone.now.ago( 90.minutes)
+            +     end
+            +     begin
+            +       md = params[:until_datetime].match(/(\d+)-(\d+)-(\d+) (\d+):(\d+)/)
+            +       @until_time = Time.zone.local(md[1].to_i,md[2].to_i,md[3].to_i,md[4].to_i,md[5].to_i)
+            +     rescue
+            +       @until_time = Time.zone.now
+            +     end
+            +
+            +     #convert sid
+            +     @sid = params[:SID].split(/[,\s]/) if params[:SID]
+            +     unless @sid and @sid.size > 0
+            +       return
+            +       redirect_to actoin: :cheat_scruntinize
+            +       flash[:notice] = 'Please enter at least 1 student id'
+            +     end
+            +     mark = Array.new(@sid.size,'?')
+            +     condition = "(u.login = " + mark.join(' OR u.login = ') + ')'
+            +
+            +     @st = <<-SQL
+            +   SELECT l.created_at as submitted_at ,-1 as id,u.login,u.full_name,l.ip_address,"" as problem_id,"" as points,l.user_id
+            +   FROM logins l INNER JOIN users u on l.user_id  = u.id
+            +   WHERE l.created_at >= ? AND l.created_at <= ? AND #{condition}
+            + UNION
+            +   SELECT s.submitted_at,s.id,u.login,u.full_name,s.ip_address,s.problem_id,s.points,s.user_id
+            +   FROM submissions s INNER JOIN users u ON s.user_id = u.id
+            +   WHERE s.submitted_at >= ? AND s.submitted_at <= ? AND #{condition}
+            + ORDER BY submitted_at
+            +   SQL
+            +
+            +     p = [@st,@since_time,@until_time] + @sid + [@since_time,@until_time] + @sid
+            +     @logs = Submission.joins(:problem).find_by_sql(p)
+            +
+            +
+            +
+            +
+            +
+            +   end
+            +
+            +
+            + end

app/models/login.rb ¶ +2

               class Login < ActiveRecord::Base
+            +   belongs_to :user
+            +
                 attr_accessible :ip_address, :logged_in_at, :user_id
               end

app/models/user.rb ¶ +4

                       resp = http.request(req,param)
                       result = JSON.parse resp.body
                     end
                     return true if result["type"] == "beanStudent"
                   rescue
                     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.find(: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.find(: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 available_problems
                   if not GraderConfiguration.multicontests?
                     return Problem.find_available_problems
                   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 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
                   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/report/_date_range.html.haml ¶ +2 -2

               = form_tag({session: :url })  do
                 .submitbox
                   %table
                     %tr
                       %td{colspan: 6, style: 'font-weight: bold'}= title
                     %tr
                       %td{style: 'width: 120px; font-weight: bold'}= param_text
                       %td{align: 'right'} since:
-            -         %td= text_field_tag 'since_datetime'
+            +         %td= text_field_tag 'since_datetime', @since_time
                     %tr
                       %td
                       %td{align: 'right'} until:
-            -         %td= text_field_tag 'until_datetime'
+            +         %td= text_field_tag 'until_datetime', @until_time
                     %tr
                       %td
                       %td
                       %td Blank mean no condition
                     %tr
                       %td
                       %td
                       %td= submit_tag 'query'

app/views/report/_report_menu.html.haml ¶ +2 -1

               .task-menu
                 Reports
                 %br/
                 = link_to '[Hall of Fame]', :action => 'problem_hof'
                 = link_to '[Struggle]', :action => 'stuck'
-            -   = link_to '[Login]', :action => 'login_stat'
+            +   = link_to '[Cheat Detection]', :action => 'cheat_report'
+            +   = link_to '[Cheat Detail]', :action => 'cheat_scruntinize'
                 = link_to '[Multiple Login]', :action => 'multiple_login'

db/schema.rb ¶ +3 -2

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

db/seeds.rb ¶ +7

               CONFIGURATIONS =
                 [
                  {
                    :key => 'system.single_user_mode',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'Only admins can log in to the system when running under single user mode.'
                  },
                  {
                    :key => 'ui.front.title',
                    :value_type => 'string',
                    :default_value => 'Grader'
                  },
                  {
                    :key => 'ui.front.welcome_message',
                    :value_type => 'string',
                    :default_value => 'Welcome!'
                  },
                  {
                    :key => 'ui.show_score',
                    :value_type => 'boolean',
                    :default_value => 'true'
                  },
                  {
                    :key => 'contest.time_limit',
                    :value_type => 'string',
                    :default_value => 'unlimited',
                    :description => 'Time limit in format hh:mm, or "unlimited" for contests with no time limits.  This config is CACHED.  Restart the server before the change can take effect.'
                  },
                  {
                    :key => 'system.mode',
                    :value_type => 'string',
                    :default_value => 'standard',
                    :description => 'Current modes are "standard", "contest", "indv-contest", and "analysis".'
                  },
                  {
                    :key => 'contest.name',
                    :value_type => 'string',
                    :default_value => 'Grader',
                    :description => 'This name will be shown on the user header bar.'
                  },
                  {
                    :key => 'contest.multisites',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'If the server is in contest mode and this option is true, on the log in of the admin a menu for site selections is shown.'
                  },
                  {
                    :key => 'right.user_hall_of_fame',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'If true, any user can access hall of fame page.'
                  },
                  {
+            +      :key => 'right.multiple_ip_login',
+            +      :value_type => 'boolean',
+            +      :default_value => 'true',
+            +      :description => 'When change from true to false, a user can login from the first IP they logged into afterward.'
+            +    },
+            +
+            +    {
                    :key => 'right.user_view_submission',
                    :value_type => 'boolean',
                    :default_value => 'false',
                    :description => 'If true, any user can view submissions of every one.'
                  },
                  # If Configuration['system.online_registration'] is true, the
                  # system allows online registration, and will use these
                  # information for sending confirmation emails.
                  {
                    :key => 'system.online_registration.smtp',
                    :value_type => 'string',
                    :default_value => 'smtp.somehost.com'
                  },
                  {
                    :key => 'system.online_registration.from',
                    :value_type => 'string',
                    :default_value => 'your.email@address'
                  },
                  {
                    :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."
                  }
                 ]
               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;
                 role.save
               end
               def seed_root
                 return if User.find_by_login('root')
                 root = User.new(:login => 'root',
                                 :full_name => 'Administrator',
                                 :alias => 'root')
                 root.password = 'ioionrails';
                 class << root
                   public :encrypt_new_password
                   def valid?(context=nil)
                     true
                   end
                 end
                 root.encrypt_new_password
                 root.roles << Role.find_by_name('admin')
                 root.activated = true
                 root.save
               end
               def seed_users_and_roles
                 seed_roles
                 seed_root
               end
               def seed_more_languages
                 Language.delete_all
                 Language.create( name: 'c', pretty_name: 'C', ext: 'c', common_ext: 'c' )
                 Language.create( name: 'cpp', pretty_name: 'C++', ext: 'cpp', common_ext: 'cpp,cc' )
                 Language.create( name: 'pas', pretty_name: 'Pascal', ext: 'pas', common_ext: 'pas' )
                 Language.create( name: 'ruby', pretty_name: 'Ruby', ext: 'rb', common_ext: 'rb' )
                 Language.create( name: 'python', pretty_name: 'Python', ext: 'py', common_ext: 'py' )
                 Language.create( name: 'java', pretty_name: 'Java', ext: 'java', common_ext: 'java' )
               end
               seed_config
               seed_users_and_roles
               seed_more_languages

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

r526:f7b4a30e2f5d - Tue, 11 Aug 2015 11:28:41 - 12 files changed: 252 inserted, 6 deleted

Sign in to your account

Commit r526:f7b4a30e2f5d public

Author

r526:f7b4a30e2f5d - Tue, 11 Aug 2015 11:28:41 - 12 files changed: 252 inserted, 6 deleted

Commit `r526:f7b4a30e2f5d` public