cafe-grader-web Commit - r792:6ae18fbc4b91

cafe-grader-web

Commit `r792:6ae18fbc4b91` public

parent | child

Description:

- login report - fix bugs on pagination on user manage

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r792:6ae18fbc4b91 - Sun, 05 Apr 2020 13:20:15 - 14 files changed: 255 inserted, 76 deleted

app/views/report/login.html.haml created 644 ¶ +130

@@ -0,0 +1,130
	1	+ - content_for :header do
	2	+ = javascript_include_tag 'local_jquery'
	3	+
	4	+ %h1 Logins detail
	5	+
	6	+ .row
	7	+ .col-md-4
	8	+ .alert.alert-info
	9	+ %ul
	10	+ %li You have to click refresh when changing the filter above
	11	+ %li Detail tab shows each logins separately
	12	+ %li Summary tab shows logins summary of each user
	13	+ .col-md-4
	14	+ = render partial: 'shared/date_filter'
	15	+ .col-md-4
	16	+ = render partial: 'shared/user_select'
	17	+
	18	+ .row.form-group
	19	+ .col-sm-12
	20	+ %ul.nav.nav-tabs
	21	+ %li.active
	22	+ %a{href: '#detail', data: {toggle: :tab}} Detail
	23	+ %li
	24	+ %a{href: '#summary', data: {toggle: :tab}} Summary
	25	+ .row
	26	+ .col-sm-12
	27	+ .tab-content
	28	+ .tab-pane.active#detail
	29	+ %table#detail-table.table.table-hover.table-condense.datatable{style: 'width: 100%'}
	30	+ .tab-pane#summary
	31	+ %table#summary-table.table.table-hover.table-condense.datatable{style: 'width: 100%'}
	32	+
	33	+
	34	+
	35	+ :javascript
	36	+ $(function() {
	37	+ detail_table = $('#detail-table').DataTable({
	38	+ dom: "<'row'<'col-sm-3'B><'col-sm-3'l><'col-sm-6'f>>" + "<'row'<'col-sm-12'tr>>" + "<'row'<'col-sm-5'i><'col-sm-7'p>>",
	39	+ autoWidth: true,
	40	+ buttons: [
	41	+ {
	42	+ text: 'Refresh',
	43	+ action: (e,dt,node,config) => {
	44	+ detail_table.clear().draw()
	45	+ detail_table.ajax.reload( () => { detail_table.columns.adjust().draw() } )
	46	+ summary_table.clear().draw()
	47	+ summary_table.ajax.reload( () => { summary_table.columns.adjust().draw() } )
	48	+ }
	49	+ },
	50	+ 'copy',
	51	+ {
	52	+ extend: 'excel',
	53	+ title: 'Login detail',
	54	+ }
	55	+ ],
	56	+ columns: [
	57	+ {title: 'User', data: 'login_text'},
	58	+ {title: 'Time', data: 'created_at'},
	59	+ {title: 'IP', data: 'ip_address'},
	60	+ ],
	61	+ ajax: {
	62	+ url: '#{login_detail_query_report_path}',
	63	+ type: 'POST',
	64	+ data: (d) => {
	65	+ d.since_datetime = $('#since_datetime').val()
	66	+ d.until_datetime = $('#until_datetime').val()
	67	+ d.users = $("input[name='users']:checked").val()
	68	+ d.groups = $("#group_id").select2('val')
	69	+ },
	70	+ dataType: 'json',
	71	+ beforeSend: (request) => {
	72	+ request.setRequestHeader('X-CSRF-Token', $('meta[name="csrf-token"]').attr('content'));
	73	+ },
	74	+ }, //end ajax
	75	+ pageLength: 25,
	76	+ processing: true,
	77	+ });
	78	+
	79	+ summary_table = $('#summary-table').DataTable({
	80	+ dom: "<'row'<'col-sm-3'B><'col-sm-3'l><'col-sm-6'f>>" + "<'row'<'col-sm-12'tr>>" + "<'row'<'col-sm-5'i><'col-sm-7'p>>",
	81	+ autoWidth: true,
	82	+ buttons: [
	83	+ {
	84	+ text: 'Refresh',
	85	+ action: (e,dt,node,config) => {
	86	+ summary_table.clear().draw()
	87	+ summary_table.ajax.reload( () => { summary_table.columns.adjust().draw() } )
	88	+ detail_table.clear().draw()
	89	+ detail_table.ajax.reload( () => { detail_table.columns.adjust().draw() } )
	90	+ }
	91	+ },
	92	+ 'copy',
	93	+ {
	94	+ extend: 'excel',
	95	+ title: 'Login summary',
	96	+ }
	97	+ ],
	98	+ columns: [
	99	+ {title: 'User', data: 'login_text'},
	100	+ {title: 'Login Count', data: 'count'},
	101	+ {title: 'Earliest', data: 'earliest'},
	102	+ {title: 'Latest', data: 'latest'},
	103	+ {title: 'IP', data: 'ip_address'},
	104	+ ],
	105	+ ajax: {
	106	+ url: '#{login_summary_query_report_path}',
	107	+ type: 'POST',
	108	+ data: (d) => {
	109	+ d.since_datetime = $('#since_datetime').val()
	110	+ d.until_datetime = $('#until_datetime').val()
	111	+ d.users = $("input[name='users']:checked").val()
	112	+ d.groups = $("#group_id").select2('val')
	113	+ },
	114	+ dataType: 'json',
	115	+ beforeSend: (request) => {
	116	+ request.setRequestHeader('X-CSRF-Token', $('meta[name="csrf-token"]').attr('content'));
	117	+ },
	118	+ }, //end ajax
	119	+ pageLength: 25,
	120	+ processing: true,
	121	+ });
	122	+
	123	+ $('.input-group.date').datetimepicker({
	124	+ format: 'YYYY-MM-DD HH:mm',
	125	+ showTodayButton: true,
	126	+ locale: 'en',
	127	+ widgetPositioning: {horizontal: 'auto', vertical: 'bottom'},
	128	+ defaultDate: moment()
	129	+ });
	130	+ });

app/views/report/login_detail_query.json.jbuilder created 644 ¶ +10

@@ -0,0 +1,10
	1	+ json.draw params['draw']&.to_i
	2	+ json.recordsTotal @recordsTotal
	3	+ json.recordsFiltered @recordsFiltered
	4	+ json.data do
	5	+ json.array! @logins do \|login\|
	6	+ json.login_text login.user ? "<a href='#{stat_user_path(login.user_id)}'>(#{login.user.login})</a> #{login.user.full_name}" : '-- deletec user --'
	7	+ json.created_at login.created_at.strftime('%Y-%m-%d %H:%M')
	8	+ json.ip_address login.ip_address
	9	+ end
	10	+ end

app/views/report/login_summary_query.json.jbuilder created 644 ¶ +12

@@ -0,0 +1,12
	1	+ json.draw params['draw']&.to_i
	2	+ json.recordsTotal @recordsTotal
	3	+ json.recordsFiltered @recordsFiltered
	4	+ json.data do
	5	+ json.array! @users do \|user\|
	6	+ json.login_text "<a href='#{stat_user_path(user[:id])}'>(#{user[:login]})</a> #{user[:full_name]}"
	7	+ json.count user[:count]
	8	+ json.earliest user[:min].strftime('%Y-%m-%d %H:%M')
	9	+ json.latest user[:max].strftime('%Y-%m-%d %H:%M')
	10	+ json.ip_address user[:ip].join('<br/>')
	11	+ end
	12	+ end

db/migrate/20200405112919_add_index_to_login.rb created 644 ¶ +5

@@ -0,0 +1,5
	1	+ class AddIndexToLogin < ActiveRecord::Migration[5.2]
	2	+ def change
	3	+ add_index :logins, :user_id
	4	+ end
	5	+ end

app/controllers/report_controller.rb ¶ +68 -26

               require 'csv'
               class ReportController < ApplicationController
                 before_action :check_valid_login
-            -   before_action :admin_authorization, only: [:login_stat,:submission, :submission_query, :stuck, :cheat_report, :cheat_scruntinize, :show_max_score, :current_score]
+            +   before_action :admin_authorization, only: [:login_stat,:submission, :submission_query,
+            +                                              :login, :login_detail_query, :login_summary_query,
+            +                                              :stuck, :cheat_report, :cheat_scruntinize, :show_max_score, :current_score]
                 before_action(only: [:problem_hof]) { |c|
                   return false unless check_valid_login
                   admin_authorization unless GraderConfiguration["right.user_view_submission"]
                 }
                 def max_score
                 end
                 def current_score
                   @problems = Problem.available_problems
                   if params[:group_id]
                     @group = Group.find(params[:group_id])
                     @users = @group.users.where(enabled: true)
                   else
                     @users = User.includes(:contests).includes(:contest_stat).where(enabled: true)
                   end
                   @scorearray = calculate_max_score(@problems, @users,0,0,true)
                   #rencer accordingly
                   if params[:button] == 'download' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'max_score.csv'
                   else
                     #render template: 'user_admin/user_stat'
                     render 'current_score'
                   end
                 end
                 def show_max_score
                   #process parameters
                   #problems
                   @problems = []
                   if params[:problem_id]
                     params[:problem_id].each do |id|
                       next unless id.strip != ""
                       pid = Problem.find_by_id(id.to_i)
                       @problems << pid if pid
                     end
                   end
                   #users
                   @users = if params[:users] == "all" then
                              User.includes(:contests).includes(:contest_stat)
                            else
                              User.includes(:contests).includes(:contest_stat).where(enabled: true)
                            end
                   #set up range from param
                   @since_id = params.fetch(:from_id, 0).to_i
                   @until_id = params.fetch(:to_id, 0).to_i
                   @since_id = nil if @since_id == 0
                   @until_id = nil if @until_id == 0
                   #calculate the routine
                   @scorearray = calculate_max_score(@problems, @users, @since_id, @until_id)
                   #rencer accordingly
                   if params[:button] == 'download' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'max_score.csv'
                   else
                     #render template: 'user_admin/user_stat'
                     render 'max_score'
                   end
                 end
                 def score
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else
                     @problems = Problem.available_problems
                   end
                   @users = User.includes(:contests, :contest_stat).where(enabled: true)
                   @scorearray = Array.new
                   @users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     @problems.each do |p|
                       sub = Submission.find_last_by_user_and_problem(u.id,p.id)
                       if (sub!=nil) and (sub.points!=nil) and p and p.full_score
                         ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
                       else
                         ustat << [0,false]
                       end
                     end
                     @scorearray << ustat
                   end
                   if params[:commit] == 'download csv' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'last_score.csv'
                   else
                     render template: 'user_admin/user_stat'
                   end
                 end
-            -   def login_stat
+            +   def login
+            +   end
+            +
+            +   def login_summary_query
+            +     @users = 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
+            +
+            +     record = User
+            +       .left_outer_joins(:logins).group('users.id')
+            +       .where("logins.created_at >= ? AND logins.created_at <= ?",@since_time, @until_time)
+            +     case params[:users]
+            +     when 'enabled'
+            +       record = record.where(enabled: true)
+            +     when 'group'
+            +       record = record.joins(:groups).where(groups: {id: params[:groups]}) if params[:groups]
+            +     end
+            +
+            +     record = record.pluck("users.id,users.login,users.full_name,count(logins.created_at),min(logins.created_at),max(logins.created_at)")
+            +     record.each do |user|
+            +       x = Login.where("user_id = ? AND created_at >= ? AND created_at <= ?",
+            +                                       user[0],@since_time,@until_time)
+            +         .pluck(:ip_address).uniq
+            +       @users << { id: user[0],
+            +                    login: user[1],
+            +                    full_name: user[2],
+            +                    count: user[3],
+            +                    min: user[4],
+            +                    max: user[5],
+            +                    ip: x
+            +                  }
+            +     end
+            +   end
+            +
+            +   def login_detail_query
                   @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
-            -                  }
+            +     @logins = Login.includes(:user).where("logins.created_at >= ? AND logins.created_at <= ?",@since_time, @until_time)
+            +     case params[:users]
+            +     when 'enabled'
+            +       @logins = @logins.where(users: {enabled: true})
+            +     when 'group'
+            +       @logins = @logins.joins(user: :groups).where(user: {groups: {id: params[:groups]}}) if params[:groups]
                   end
                 end
                 def submission
                 end
                 def submission_query
                   @submissions = Submission
                     .includes(:problem).includes(:user).includes(:language)
-            -     if params[:problem]
+            +     case params[:users]
-            -       @submission = @submission.where(problem_id: params[:problem])
+            +     when 'enabled'
+            +       @submissions = @submissions.where(users: {enabled: true})
+            +     when 'group'
+            +       @submissions = @submissions.joins(user: :groups).where(user: {groups: {id: params[:groups]}}) if params[:groups]
                   end
-            -     case params[:users]
+            +     case params[:problems]
                   when 'enabled'
-            -       @submissions = @submissions.where('user.enabled': true)
+            +       @submissions = @submissions.where(problems: {available: true})
-            -     when 'group'
+            +     when 'selected'
-            -       @submissions = @submissions.joins(user: :groups).where(user: {groups: {id: params[:groups]}}) if params[:groups]
+            +       @submissions = @submissions.where(problem_id: params[:problem_id])
                   end
                   #set default
                   params[:since_datetime] = Date.today.to_s if params[:since_datetime].blank?
                   @submissions, @recordsTotal, @recordsFiltered = process_query_record( @submissions,
                     global_search: ['user.login','user.full_name','problem.name','problem.full_name','points'],
                     date_filter: 'submitted_at',
                     date_param_since: 'since_datetime',
                     date_param_until: 'until_datetime',
                     hard_limit: 100_000
                   )
                 end
+            +   def login
+            +   end
+            +
                 def problem_hof
                   # gen problem list
                   @user = User.find(session[:user_id])
                   @problems = @user.available_problems
                   # get selected problems or the default
                   if params[:id]
                     begin
                       @problem = Problem.available.find(params[:id])
                     rescue
                       redirect_to action: :problem_hof
                       flash[:notice] = 'Error: submissions for that problem are not viewable.'
                       return
                     end
                   end
                   return unless @problem
                   @by_lang = {} #aggregrate by language
                   range =65
                   @histogram = { data: Array.new(range,0), summary: {} }
                   @summary = {count: 0, solve: 0, attempt: 0}
                   user = Hash.new(0)
                   Submission.where(problem_id: @problem.id).find_each do |sub|
                     #histogram
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     @histogram[:data][d.to_i] += 1 if d < range
                     next unless sub.points
                     @summary[:count] += 1
                     user[sub.user_id] = [user[sub.user_id], (sub.points >= @problem.full_score) ? 1 : 0].max
                     lang = Language.find_by_id(sub.language_id)
                     next unless lang
                     next unless sub.points >= @problem.full_score
                     #initialize
                     unless @by_lang.has_key?(lang.pretty_name)
                       @by_lang[lang.pretty_name] = {
                         runtime: { avail: false, value: 2**30-1 },
                         memory: { avail: false, value: 2**30-1 },
                         length: { avail: false, value: 2**30-1 },
                         first: { avail: false, value: DateTime.new(3000,1,1) }
                       }
                     end
                     if sub.max_runtime and sub.max_runtime < @by_lang[lang.pretty_name][:runtime][:value]
                       @by_lang[lang.pretty_name][:runtime] = { avail: true, user_id: sub.user_id, value: sub.max_runtime, sub_id: sub.id }
                     end
                     if sub.peak_memory and sub.peak_memory < @by_lang[lang.pretty_name][:memory][:value]
                       @by_lang[lang.pretty_name][:memory] = { avail: true, user_id: sub.user_id, value: sub.peak_memory, sub_id: sub.id }
                     end
                     if sub.submitted_at and sub.submitted_at < @by_lang[lang.pretty_name][:first][:value] and sub.user and
                         !sub.user.admin?
                       @by_lang[lang.pretty_name][:first] = { avail: true, user_id: sub.user_id, value: sub.submitted_at, sub_id: sub.id }
                     end
                     if @by_lang[lang.pretty_name][:length][:value] > sub.effective_code_length
                       @by_lang[lang.pretty_name][:length] = { avail: true, user_id: sub.user_id, value: sub.effective_code_length, sub_id: sub.id }
                     end
                   end
                   #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
                 protected
                 def calculate_max_score(problems, users,since_id,until_id, get_last_score = false)
                   #scorearray[i] = user #i's user stat where i is the index (not id)
                   scorearray = Array.new
                   users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     problems.each do |p|
                       unless get_last_score
                         #get max score
                         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)]
                       else
                         #get latest score
                         sub = Submission.find_last_by_user_and_problem(u.id,p.id)
                         if (sub!=nil) and (sub.points!=nil) and p and p.full_score
                           ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
                         else
                           ustat << [0,false]
                         end
                       end
                     end
                     scorearray << ustat
                   end
                   return scorearray
                 end
                 def gen_csv_from_scorearray(scorearray,problem)
                   CSV.generate do |csv|
                     #add header
                     header = ['User','Name', 'Activated?', 'Logged in', 'Contest']
                     problem.each { |p| header << p.name }
                     header += ['Total','Passed']
                     csv << header
                     #add data
                     scorearray.each do |sc|
                       total = num_passed = 0
                       row = Array.new
                       sc.each_index do |i|
                         if i == 0
                           row << sc[i].login
                           row << sc[i].full_name
                           row << sc[i].activated
                           row << (sc[i].try(:contest_stat).try(:started_at)!=nil ? 'yes' : 'no')
                           row << sc[i].contests.collect {|c| c.name}.join(', ')
                         else
                           row << sc[i][0]
                           total += sc[i][0]
                           num_passed += 1 if sc[i][1]
                         end
                       end
                       row << total
                       row << num_passed
                       csv << row
                     end
                   end
                 end
               end

app/controllers/user_admin_controller.rb ¶ -7

               require 'csv'
               class UserAdminController < ApplicationController
                 include MailHelperMethods
                 before_action :admin_authorization
                 def index
                   @user_count = User.count
-            -     if params[:page] == 'all'
-            -       @users = User.all
-            -       @paginated = false
-            -     else
-            -       @users = User.paginate :page => params[:page]
-            -       @paginated = true
-            -     end
                   @users = User.all
                   @hidden_columns = ['hashed_password', 'salt', 'created_at', 'updated_at']
                   @contests = Contest.enabled
                 end
                 def active
                   sessions = ActiveRecord::SessionStore::Session.where("updated_at >= ?", 60.minutes.ago)
                   @users = []
                   sessions.each do |session|
                     if session.data[:user_id]
                       @users << User.find(session.data[:user_id])
                     end
                   end
                 end
                 def show
                   @user = User.find(params[:id])
                 end
                 def new
                   @user = User.new
                 end
                 def create
                   @user = User.new(user_params)
                   @user.activated = true
                   if @user.save
                     flash[:notice] = 'User was successfully created.'
                     redirect_to :action => 'index'
                   else
                     render :action => 'new'
                   end
                 end
                 def clear_last_ip
                   @user = User.find(params[:id])
                   @user.last_ip = nil
                   @user.save
                   redirect_to action: 'index', page: params[:page]
                 end
                 def create_from_list
                   lines = params[:user_list]
                   note = []
                   error_note = []
                   error_msg = nil
                   ok_user = []
                   lines.split("\n").each do |line|
                     items = line.chomp.split(',')
                     if items.length>=2
                       login = items[0]
                       full_name = items[1]
                       remark =''
                       user_alias = ''
                       added_random_password = false
                       if items.length >= 3 and items[2].chomp(" ").length > 0;
                         password = items[2].chomp(" ")
                       else
                         password = random_password
                         added_random_password=true;
                       end
                       if items.length>= 4 and items[3].chomp(" ").length > 0;
                         user_alias = items[3].chomp(" ")
                       else
                         user_alias = login
                       end
                       if items.length>=5
                         remark = items[4].strip;
                       end
                       user = User.find_by_login(login)
                       if (user)
                         user.full_name = full_name
                         user.password = password
                         user.remark = remark
                       else
                         user = User.new({:login => login,
                                          :full_name => full_name,
                                          :password => password,
                                          :password_confirmation => password,
                                          :alias => user_alias,
                                          :remark => remark})
                       end
                       user.activated = true
                       if user.save
                         if added_random_password
                           note << "'#{login}' (+)"
                         else
                           note << login
                         end
                         ok_user << user
                       else
                         error_note << "'#{login}'"
                         error_msg = user.errors.full_messages.to_sentence unless error_msg
                       end
                     end
                   end
                   #add to group
                   if params[:add_to_group]
                     group = Group.where(id: params[:group_id]).first
                     if group
                       group.users << ok_user
                     end
                   end
                   # show flash
                   if note.size > 0
                     flash[:success] = 'User(s) ' + note.join(', ') +
                       ' were successfully created.  ' +
                       '( (+) - created with random passwords.)'
                   end
                   if error_note.size > 0
                     flash[:error] = "Following user(s) failed to be created: " + error_note.join(', ') + ". The error of the first failed one are: " + error_msg;
                   end
                   redirect_to :action => 'index'
                 end
                 def edit
                   @user = User.find(params[:id])
                 end
                 def update
                   @user = User.find(params[:id])
                   if @user.update_attributes(user_params)
                     flash[:notice] = 'User was successfully updated.'
                     redirect_to :action => 'show', :id => @user
                   else
                     render :action => 'edit'
                   end
                 end
                 def destroy
                   User.find(params[:id]).destroy
                   redirect_to :action => 'index'
                 end
                 def user_stat
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else
                     @problems = Problem.available_problems
                   end
                   @users = User.includes(:contests, :contest_stat).where(enabled: true)
                   @scorearray = Array.new
                   @users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     @problems.each do |p|
                       sub = Submission.find_last_by_user_and_problem(u.id,p.id)
                       if (sub!=nil) and (sub.points!=nil) and p and p.full_score
                         ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
                       else
                         ustat << [0,false]
                       end
                     end
                     @scorearray << ustat
                   end
                   if params[:commit] == 'download csv' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'last_score.csv'
                   else
                     render template: 'user_admin/user_stat'
                   end
                 end
                 def user_stat_max
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else
                     @problems = Problem.available_problems
                   end
                   @users = User.includes(:contests).includes(:contest_stat).all
                   @scorearray = Array.new
                   #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 params[:commit] == 'Go ahead'
                     @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
                   contest = Contest.find(params[:contest][:id])
                   if !contest
                     flash[:notice] = 'You did not choose the contest.'
                     redirect_to :action => 'contest_management' and return
                   end
                   operation = params[:operation]
                   if not ['add','remove','assign'].include? operation
                     flash[:notice] = 'You did not choose the operation to perform.'
                     redirect_to :action => 'contest_management' and return
                   end
                   lines = params[:login_list]
                   if !lines or lines.blank?
                     flash[:notice] = 'You entered an empty list.'
                     redirect_to :action => 'contest_management' and return
                   end
                   note = []
                   users = []
                   lines.split("\n").each do |line|
                     user = User.find_by_login(line.chomp)
                     if user
                       if operation=='add'
                         if ! user.contests.include? contest
                           user.contests << contest
                         end
                       elsif operation=='remove'
                         user.contests.delete(contest)
                       else
                         user.contests = [contest]
                       end
                       if params[:reset_timer]
                         user.contest_stat.forced_logout = true
                         user.contest_stat.reset_timer_and_save
                       end
                       if params[:notification_emails]
                         send_contest_update_notification_email(user, contest)
                       end
                       note << user.login
                       users << user
                     end
                   end
                   if params[:reset_timer]
                     logout_users(users)
                   end
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     ' were successfully modified.  '
                   redirect_to :action => 'contest_management'
                 end
                 # admin management
                 def admin
                   @admins = User.all.find_all {|user| user.admin? }
                 end
                 def grant_admin
                   login = params[:login]
                   user = User.find_by_login(login)
                   if user!=nil
                     admin_role = Role.find_by_name('admin')
                     user.roles << admin_role
                   else
                     flash[:notice] = 'Unknown user'
                   end
                   flash[:notice] = 'User added as admins'
                   redirect_to :action => 'admin'
                 end
                 def revoke_admin
                   user = User.find(params[:id])
                   if user==nil
                     flash[:notice] = 'Unknown user'
                     redirect_to :action => 'admin' and return
                   elsif user.login == 'root'
                     flash[:notice] = 'You cannot revoke admisnistrator permission from root.'
                     redirect_to :action => 'admin' and return
                   end
                   admin_role = Role.find_by_name('admin')
                   user.roles.delete(admin_role)
                   flash[:notice] = 'User permission revoked'
                   redirect_to :action => 'admin'
                 end
                 # mass mailing
                 def mass_mailing
                 end
                 def bulk_mail
                   lines = params[:login_list]
                   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.'

app/models/user.rb ¶ +2

               require 'digest/sha1'
               require 'net/pop'
               require 'net/https'
               require 'net/http'
               require 'json'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
                 #has_and_belongs_to_many :groups
                 has_many :groups_users, class_name: 'GroupUser'
                 has_many :groups, :through => :groups_users
                 has_many :test_requests, -> {order(submitted_at: :desc)}
                 has_many :messages, -> { order(created_at: :desc) },
                          :class_name => "Message",
                          :foreign_key => "sender_id"
                 has_many :replied_messages, -> { order(created_at: :desc) },
                          :class_name => "Message",
                          :foreign_key => "receiver_id"
+            +   has_many :logins
+            +
                 has_one :contest_stat, :class_name => "UserContestStat", :dependent => :destroy
                 belongs_to :site
                 belongs_to :country
                 has_and_belongs_to_many :contests, -> { order(:name)}
                 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..50, :if => :password_required?
                 validates_confirmation_of :password, :if => :password_required?
                 validates_format_of :email,
                                     :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i,
                                     :if => :email_validation?
                 validate :uniqueness_of_email_from_activated_users,
                          :if => :email_validation?
                 validate :enough_time_interval_between_same_email_registrations,
                          :if => :email_validation?
                 # these are for ytopc
                 # disable for now
                 #validates_presence_of :province
                 attr_accessor :password
                 before_save :encrypt_new_password
                 before_save :assign_default_site
                 before_save :assign_default_contest
                 # this is for will_paginate
                 cattr_reader :per_page
                 @@per_page = 50
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   if user
                     return user if user.authenticated?(password)
                   end
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def admin?
                   self.roles.where(name: 'admin').count > 0
                 end
                 def email_for_editing
                   if self.email==nil
                     "(unknown)"
                   elsif self.email==''
                     "(blank)"
                   else
                     self.email
                   end
                 end
                 def email_for_editing=(e)
                   self.email=e
                 end
                 def alias_for_editing
                   if self.alias==nil
                     "(unknown)"
                   elsif self.alias==''
                     "(blank)"
                   else
                     self.alias
                   end
                 end
                 def alias_for_editing=(e)
                   self.alias=e
                 end
                 def activation_key
                   if self.hashed_password==nil
                     encrypt_new_password
                   end
                   Digest::SHA1.hexdigest(self.hashed_password)[0..7]
                 end
                 def verify_activation_key(key)
                   key == activation_key
                 end
                 def self.random_password(length=5)
                   chars = 'abcdefghjkmnopqrstuvwxyz'
                   password = ''
                   length.times { password << chars[rand(chars.length - 1)] }
                   password
                 end
                 def self.find_non_admin_with_prefix(prefix='')
                   users = User.all
                   return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
                 end
                 # Contest information
                 def self.find_users_with_no_contest()
                   users = User.all
                   return users.find_all { |u| u.contests.length == 0 }
                 end
                 def contest_time_left
                   if GraderConfiguration.contest_mode?
                     return nil if site==nil
                     return site.time_left
                   elsif GraderConfiguration.indv_contest_mode?
                     time_limit = GraderConfiguration.contest_time_limit
                     if time_limit == nil
                       return nil
                     end
                     if contest_stat==nil or contest_stat.started_at==nil
                       return (Time.now.gmtime + time_limit) - Time.now.gmtime
                     else
                       finish_time = contest_stat.started_at + time_limit
                       current_time = Time.now.gmtime
                       if current_time > finish_time
                         return 0
                       else
                         return finish_time - current_time
                       end
                     end
                   else
                     return nil
                   end
                 end
                 def contest_finished?
                   if GraderConfiguration.contest_mode?
                     return false if site==nil
                     return site.finished?
                   elsif GraderConfiguration.indv_contest_mode?
                     return false if self.contest_stat==nil
                     return contest_time_left == 0
                   else
                     return false
                   end
                 end
                 def contest_started?
                   if GraderConfiguration.indv_contest_mode?
                     stat = self.contest_stat
                     return ((stat != nil) and (stat.started_at != nil))
                   elsif GraderConfiguration.contest_mode?
                     return true if site==nil
                     return site.started
                   else
                     return true
                   end
                 end
                 def update_start_time
                   stat = self.contest_stat
                   if stat.nil? or stat.started_at.nil?
                     stat ||= UserContestStat.new(:user => self)
                     stat.started_at = Time.now.gmtime
                     stat.save
                   end
                 end
                 def problem_in_user_contests?(problem)
                   problem_contests = problem.contests.all
                   if problem_contests.length == 0   # this is public contest
                     return true
                   end
                   contests.each do |contest|
                     if problem_contests.find {|c| c.id == contest.id }
                       return true
                     end
                   end
                   return false
                 end
                 def available_problems_group_by_contests
                   contest_problems = []
                   pin = {}
                   contests.enabled.each do |contest|
                     available_problems = contest.problems.available
                     contest_problems << {
                       :contest => contest,
                       :problems => available_problems
                     }
                     available_problems.each {|p| pin[p.id] = true}
                   end
                   other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
                   contest_problems << {
                     :contest => nil,
                     :problems => other_avaiable_problems
                   }
                   return contest_problems
                 end
                 def solve_all_available_problems?
                   available_problems.each do |p|
                     u = self
                     sub = Submission.find_last_by_user_and_problem(u.id,p.id)
                     return false if !p or !sub or sub.points < p.full_score
                   end
                   return true
                 end
                 #get a list of available problem
                 def available_problems
                   # first, we check if this is normal mode
                   if not GraderConfiguration.multicontests?
                     #if this is a normal mode
                     #we show problem based on problem_group, if the config said so
                     if GraderConfiguration.use_problem_group?
                       return available_problems_in_group
                     else
                       return Problem.available_problems
                     end
                   else
                     #this is multi contest mode
                     contest_problems = []
                     pin = {}
                     contests.enabled.each do |contest|
                       contest.problems.available.each do |problem|
                         if not pin.has_key? problem.id
                           contest_problems << problem
                         end
                         pin[problem.id] = true
                       end
                     end
                     other_avaiable_problems = Problem.available.find_all {|p| pin[p.id]==nil and p.contests.length==0}
                     return contest_problems + other_avaiable_problems
                   end
                 end
                 def available_problems_in_group
                   problem = []
                   self.groups.each do |group|
                     group.problems.where(available: true).each { |p| problem << p }
                   end
                   problem.uniq!
                   if problem
                     problem.sort! do |a,b|
                       case
                       when a.date_added < b.date_added
                       when a.date_added > b.date_added
                         -1
                       else
                         a.name <=> b.name
                       end
                     end
                     return problem
                   else
                     return []
                   end
                 end
                 def can_view_problem?(problem)
                   return true if admin?
                   return available_problems.include? problem
                 end
                 def self.clear_last_login
                   User.update_all(:last_ip => nil)
                 end
                 protected
                   def encrypt_new_password
                     return if password.blank?
                     self.salt = (10+rand(90)).to_s
                     self.hashed_password = User.encrypt(self.password,self.salt)
                   end
                   def assign_default_site
                     # have to catch error when migrating (because self.site is not available).
                     begin
                       if self.site==nil
                         self.site = Site.find_by_name('default')
                         if self.site==nil
                           self.site = Site.find(1)  # when 'default has be renamed'
                         end
                       end
                     rescue
                     end
                   end
                   def assign_default_contest
                     # have to catch error when migrating (because self.site is not available).
                     begin
                       if self.contests.length == 0
                         default_contest = Contest.find_by_name(GraderConfiguration['contest.default_contest_name'])
                         if default_contest
                           self.contests = [default_contest]
                         end
                       end
                     rescue
                     end
                   end
                   def password_required?
                     self.hashed_password.blank? || !self.password.blank?
                   end
                   def self.encrypt(string,salt)
                     Digest::SHA1.hexdigest(salt + string)
                   end
                   def uniqueness_of_email_from_activated_users
                     user = User.activated_users.find_by_email(self.email)
                     if user and (user.login != self.login)
                       self.errors.add(:base,"Email has already been taken")
                     end
                   end
                   def enough_time_interval_between_same_email_registrations
                     return if !self.new_record?
                     return if self.activated
                     open_user = User.find_by_email(self.email,
                                                    :order => 'created_at DESC')
                     if open_user and open_user.created_at and
                         (open_user.created_at > Time.now.gmtime - 5.minutes)
                       self.errors.add(:base,"There are already unactivated registrations with this e-mail address (please wait for 5 minutes)")
                     end
                   end
                   def email_validation?
                     begin
                       return VALIDATE_USER_EMAILS
                     rescue
                       return false
                     end
                   end
               end

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

               %header.navbar.navbar-default.navbar-fixed-top
                 %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: list_main_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( 'Tags', 'tags', '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( 'Submission Report', 'report', 'submission')
+            +                 = add_menu( 'Login Report', 'report', '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', 'index', {title: I18n.t('menu.messages'), data: {toggle: 'tooltip'}})
                         - if GraderConfiguration['system.user_setting_enabled']
                           = add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-cog', id: 'user_profile')}".html_safe, 'users', 'profile', {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/report/submission.html.haml ¶ +7 -2

               - content_for :header do
                 = javascript_include_tag 'local_jquery'
               %h1 Submissions detail
               .row
                 .col-md-4
                   = render partial: 'shared/problem_select'
                 .col-md-4
                   = render partial: 'shared/date_filter'
                 .col-md-4
                   = render partial: 'shared/user_select'
               .row
                 .col-md-6
                   .alert.alert-info
                     %ul
                       %li Display a maximum of 100,000 entries to save computation power
                       %li You have to click refresh when changing the filter above
               .row
                 .col-sm-12
                   %table.table.table-hover.table-condense.datatable{style: 'width: 100%'}
               :javascript
                 $(function() {
                   submission_table = $('.datatable').DataTable({
                     dom: "<'row'<'col-sm-3'B><'col-sm-3'l><'col-sm-6'f>>" + "<'row'<'col-sm-12'tr>>" + "<'row'<'col-sm-5'i><'col-sm-7'p>>",
                     autoWidth: true,
                     buttons: [
                       {
                         text: 'Refresh',
                         action: (e,dt,node,config) => {
                           submission_table.clear().draw()
                           submission_table.ajax.reload( () => { submission_table.columns.adjust().draw() } )
                         }
                       },
-            -         'copy', 'excel'
+            +         'copy',
+            +         {
+            +           extend: 'excel',
+            +           title: 'Submission detail'
+            +         }
                     ],
                     columns: [
                       {title: 'Sub ID', data: 'id'},
                       {title: 'User', data: 'user.login'},
                       {title: 'Problem', data: 'problem.long_name'},
                       {title: 'Language', data: 'language.pretty_name'},
                       {title: 'Submit at', data: 'submitted_at'},
                       {title: 'Result', data: 'grader_comment'},
                       {title: 'Score', data: 'points'},
                       {title: 'IP', data: 'ip_address'},
                     ],
                     ajax: {
                       url: '#{submission_query_report_path}',
                       type: 'POST',
                       data: (d) =>  {
                         d.since_datetime = $('#since_datetime').val()
                         d.until_datetime = $('#until_datetime').val()
                         d.users = $("input[name='users']:checked").val()
-            -           d.problems = $("#problem_id").select2('val')
                         d.groups = $("#group_id").select2('val')
+            +           d.problems = $("input[name='problems']:checked").val()
+            +           d.problem_id = $("#problem_id").select2('val')
                       },
                       dataType: 'json',
                       beforeSend: (request) => {
                         request.setRequestHeader('X-CSRF-Token', $('meta[name="csrf-token"]').attr('content'));
                       },
                     }, //end ajax
                     'pageLength': 50,
                     processing: true,
                   });
                   $('.input-group.date').datetimepicker({
                     format: 'YYYY-MM-DD',
                     showTodayButton: true,
                     locale: 'en',
                     widgetPositioning: {horizontal: 'auto', vertical: 'bottom'},
                     defaultDate: moment()
                   });
                 });

app/views/shared/_problem_select.html.haml ¶ +12 -3

@@ -1,10 +1,19
1	.panel.panel-primary	1	.panel.panel-primary
2	.panel-heading	2	.panel-heading
3	Problems	3	Problems
4	.panel-body	4	.panel-body
5	- %p	5	+ .radio
6	- Select problem(s) to be included in the report	6	+ %label
7	- = label_tag :problem_id, "Problems"	7	+ = radio_button_tag 'problems', 'all', (params[:users] == "all")
		8	+ All problems
		9	+ .radio
		10	+ %label
		11	+ = radio_button_tag 'problems', 'enabled', (params[:users] == "enabled"), checked: true
		12	+ Only problems with available = "yes"
		13	+ .radio
		14	+ %label
		15	+ = radio_button_tag 'problems', 'selected', (params[:users] == "group")
		16	+ Only these selected problems
8	= select_tag 'problem_id[]',	17	= select_tag 'problem_id[]',
9	options_for_select(Problem.all.collect {\|p\| ["[#{p.name}] #{p.full_name}", p.id]},params[:problem_id]),	18	options_for_select(Problem.all.collect {\|p\| ["[#{p.name}] #{p.full_name}", p.id]},params[:problem_id]),
10	{ id: :problem_id, class: 'select2 form-control', multiple: "true" }	19	{ id: :problem_id, class: 'select2 form-control', multiple: "true" }

app/views/shared/_user_select.html.haml ¶ +1 -1

               .panel.panel-primary
                 .panel-heading
                   Users
                 .panel-body
                   .radio
                     %label
                       = radio_button_tag 'users', 'all', (params[:users] == "all")
                       All users
                   .radio
                     %label
-            -         = radio_button_tag 'users', 'enabled', (params[:users] == "enabled")
+            +         = radio_button_tag 'users', 'enabled', (params[:users] == "enabled"), checked: true
                       Only enabled users
                   .radio
                     %label
                       = radio_button_tag 'users', 'group', (params[:users] == "group")
                       Only these groups
                   = select_tag 'group_id[]',
                       options_for_select(Group.all.collect {|g| ["[#{g.name}] #{g.description}", g.id]}),
                       { id: 'group_id', class: 'select2 form-control', multiple: "true"}

config/routes.rb ¶ +5

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

db/schema.rb ¶ +2 -1

               # 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: 2020_04_04_142959) do
+            + ActiveRecord::Schema.define(version: 2020_04_05_112919) do
                 create_table "announcements", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade 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", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade 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, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.integer "contest_id"
                   t.integer "problem_id"
                 end
                 create_table "contests_users", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.integer "contest_id"
                   t.integer "user_id"
                 end
                 create_table "countries", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.string "name"
                   t.datetime "created_at", null: false
                   t.datetime "updated_at", null: false
                 end
                 create_table "descriptions", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", 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", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade 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", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.string "host"
                   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"
                   t.index ["host", "pid"], name: "index_grader_processes_on_ip_and_pid"
                 end
                 create_table "groups", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.string "name"
                   t.string "description"
                 end
                 create_table "groups_problems", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "problem_id", null: false
                   t.integer "group_id", null: false
                   t.index ["group_id", "problem_id"], name: "index_groups_problems_on_group_id_and_problem_id"
                 end
                 create_table "groups_users", options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "group_id", null: false
                   t.integer "user_id", null: false
                   t.index ["user_id", "group_id"], name: "index_groups_users_on_user_id_and_group_id"
                 end
                 create_table "heart_beats", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "user_id"
                   t.string "ip_address"
                   t.datetime "created_at", null: false
                   t.datetime "updated_at", null: false
                   t.string "status"
                   t.index ["updated_at"], name: "index_heart_beats_on_updated_at"
                 end
                 create_table "languages", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.string "name", limit: 10
                   t.string "pretty_name"
                   t.string "ext", limit: 10
                   t.string "common_ext"
                 end
                 create_table "logins", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "user_id"
                   t.string "ip_address"
                   t.datetime "created_at", null: false
                   t.datetime "updated_at", null: false
+            +     t.index ["user_id"], name: "index_logins_on_user_id"
                 end
                 create_table "messages", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade 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", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.string "name", limit: 100
                   t.string "full_name"
                   t.integer "full_score"
                   t.date "date_added"
                   t.boolean "available"
                   t.string "url"
                   t.integer "description_id"
                   t.boolean "test_allowed"
                   t.boolean "output_only"
                   t.string "description_filename"
                   t.boolean "view_testcase"
                 end
                 create_table "problems_tags", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "problem_id"
                   t.integer "tag_id"
                   t.index ["problem_id", "tag_id"], name: "index_problems_tags_on_problem_id_and_tag_id", unique: true
                   t.index ["problem_id"], name: "index_problems_tags_on_problem_id"
                   t.index ["tag_id"], name: "index_problems_tags_on_tag_id"
                 end
                 create_table "rights", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.string "name"
                   t.string "controller"
                   t.string "action"
                 end
                 create_table "rights_roles", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.integer "right_id"
                   t.integer "role_id"
                   t.index ["role_id"], name: "index_rights_roles_on_role_id"
                 end
                 create_table "roles", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.string "name"
                 end
                 create_table "roles_users", id: false, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.integer "role_id"
                   t.integer "user_id"
                   t.index ["user_id"], name: "index_roles_users_on_user_id"
                 end
                 create_table "sessions", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.string "session_id"
                   t.text "data", limit: 16777215
                   t.datetime "updated_at"
                   t.index ["session_id"], name: "index_sessions_on_session_id"
                   t.index ["updated_at"], name: "index_sessions_on_updated_at"
                 end
                 create_table "sites", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade 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 "submission_view_logs", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "user_id"
                   t.integer "submission_id"
                   t.datetime "created_at", null: false
                   t.datetime "updated_at", null: false
                 end
                 create_table "submissions", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.integer "user_id"
                   t.integer "problem_id"
                   t.integer "language_id"
                   t.text "source", limit: 16777215
                   t.binary "binary"
                   t.datetime "submitted_at"
                   t.datetime "compiled_at"
                   t.text "compiler_message", 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"
                   t.index ["submitted_at"], name: "index_submissions_on_submitted_at"
                   t.index ["user_id", "problem_id", "number"], name: "index_submissions_on_user_id_and_problem_id_and_number", unique: true
                   t.index ["user_id", "problem_id"], name: "index_submissions_on_user_id_and_problem_id"
                 end
                 create_table "tags", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.string "name", null: false
                   t.text "description"
                   t.boolean "public"
                   t.datetime "created_at", null: false
                   t.datetime "updated_at", null: false
                 end
                 create_table "tasks", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.integer "submission_id"
                   t.datetime "created_at"
                   t.integer "status"
                   t.datetime "updated_at"
                   t.index ["submission_id"], name: "index_tasks_on_submission_id"
                 end
                 create_table "test_pairs", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.integer "problem_id"
                   t.text "input", limit: 4294967295
                   t.text "solution", limit: 4294967295
                   t.datetime "created_at", null: false
                   t.datetime "updated_at", null: false
                 end
                 create_table "test_requests", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.integer "user_id"
                   t.integer "problem_id"
                   t.integer "submission_id"
                   t.string "input_file_name"
                   t.string "output_file_name"
                   t.string "running_stat"
                   t.integer "status"
                   t.datetime "updated_at", 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"
                   t.index ["user_id", "problem_id"], name: "index_test_requests_on_user_id_and_problem_id"
                 end
                 create_table "testcases", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=latin1", force: :cascade do |t|
                   t.integer "problem_id"
                   t.integer "num"
                   t.integer "group"
                   t.integer "score"
                   t.text "input", limit: 4294967295
                   t.text "sol", limit: 4294967295
                   t.datetime "created_at", null: false
                   t.datetime "updated_at", null: false
                   t.index ["problem_id"], name: "index_testcases_on_problem_id"
                 end
                 create_table "user_contest_stats", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade 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", id: :integer, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8", force: :cascade do |t|
                   t.string "login", limit: 50
                   t.string "full_name"
                   t.string "hashed_password"
                   t.string "salt", limit: 5
                   t.string "alias"
                   t.string "email"
                   t.integer "site_id"
                   t.integer "country_id"
                   t.boolean "activated", default: false
                   t.datetime "created_at"
                   t.datetime "updated_at"
                   t.string "section"
                   t.boolean "enabled", default: true
                   t.string "remark"
                   t.string "last_ip"
                   t.index ["login"], name: "index_users_on_login", unique: true
                 end
                 add_foreign_key "problems_tags", "problems"
                 add_foreign_key "problems_tags", "tags"
               end

app/views/report/login_stat.html.haml removed ¶ -36

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

r792:6ae18fbc4b91 - Sun, 05 Apr 2020 13:20:15 - 14 files changed: 255 inserted, 76 deleted

Sign in to your account

Commit r792:6ae18fbc4b91 public

Author

r792:6ae18fbc4b91 - Sun, 05 Apr 2020 13:20:15 - 14 files changed: 255 inserted, 76 deleted

Commit `r792:6ae18fbc4b91` public