cafe-grader-web Commit - r808:8690f354dd15

cafe-grader-web

Commit `r808:8690f354dd15` public

parent | child

Description:

update new list of users

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

r808:8690f354dd15 - Mon, 09 Aug 2021 16:34:02 - 5 files changed: 111 inserted, 83 deleted

db/migrate/20210809105935_add_index_to_task_status.rb created 644 ¶ +5

@@ -0,0 +1,5
	1	+ class AddIndexToTaskStatus < ActiveRecord::Migration[5.2]
	2	+ def change
	3	+ add_index :tasks, :status
	4	+ end
	5	+ end

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

               require 'csv'
               class UserAdminController < ApplicationController
                 include MailHelperMethods
                 before_action :admin_authorization
                 def index
                   @user_count = User.count
                   @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|
-            -       #split with large limit, this will cause consecutive ',' to be result in a blank
-            -       items = line.chomp.split(',',1000)
-            -       if items.length>=2
-            -         login = items[0]
-            -         full_name = items[1]
-            -         remark =''
-            -         user_alias = ''
-            -         added_random_password = false
-            -         added_password = false
-            -         if items.length >= 3
-            -           if items[2].chomp(" ").length > 0
-            -             password = items[2].chomp(" ")
-            -             added_password = true
-            -           end
-            -         else
-            -           password = random_password
-            -           added_random_password=true;
-            -         end
-            -         if items.length>= 4 and items[3].chomp(" ").length > 0;
-            -           user_alias = items[3].chomp(" ")
-            -         else
-            -           user_alias = login
-            -         end
-            -         has_remark = false
+            +     res = User.create_from_list(lines)
-            -         if items.length>=5
+            +     error_logins = res[:error_logins]
-            -           remark = items[4].strip;
+            +     error_msg = res[:first_error]
-            -           has_remark = true
+            +     ok_user = res[:created_users]
-            -         end
-            -         user = User.find_by_login(login)
-            -         if (user)
-            -           user.full_name = full_name
-            -           user.remark = remark if has_remark
-            -           user.password = password if added_password || added_random_password
-            -         else
-            -           #create a random password if none are given
-            -           password = random_password unless password
-            -           user = User.new({:login => login,
-            -                            :full_name => full_name,
-            -                            :password => password,
-            -                            :password_confirmation => password,
-            -                            :alias => user_alias,
-            -                            :remark => remark})
-            -         end
-            -         user.activated = true
-            -         if user.save
-            -           if added_random_password
-            -             note << "'#{login}' (+)"
-            -           else
-            -             note << login
-            -           end
-            -           ok_user << user
-            -         else
-            -           error_note << "'#{login}'"
-            -           error_msg = user.errors.full_messages.to_sentence unless error_msg
-            -         end
-            -       end
-            -     end
                   #add to group
                   if params[:add_to_group]
-            -       group = Group.where(id: params[:group_id]).first
+            +       group = Group.find_by(id: params[:group_id])&.add_users_skip_existing(ok_user)
-            -       if group
-            -         group.users << ok_user
-            -       end
                   end
                   # show flash
-            -     if note.size > 0
+            +     if ok_user.count > 0
-            -       flash[:success] = 'User(s) ' + note.join(', ') +
+            +       flash[:success] = "#{ok_user.count} user(s) was created or updated successfully"
-            -         ' were successfully created.  ' +
-            -         '( (+) - created with random passwords.)'
                   end
-            -     if error_note.size > 0
+            +     if error_logins.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] || ''
                         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 = Role.where(name: 'admin').take.users
                   @tas = Role.where(name: 'ta').take.users
                 end
                 def modify_role
                   user = User.find_by_login(params[:login])
                   role = Role.find_by_name(params[:role])
                   unless user && role
                     flash[:error] = 'Unknown user or role'
                     redirect_to admin_user_admin_index_path
                     return
                   end
                   if params[:commit] == 'Grant'
                     #grant role
                     user.roles << role
                     flash[:notice] = "User '#{user.login}' has been granted the role '#{role.name}'"
                   else
                     #revoke role
                     if user.login == 'root' && role.name == 'admin'
                       flash[:error] = 'You cannot revoke admisnistrator permission from root.'
                       redirect_to admin_user_admin_index_path
                       return
                     end
                     user.roles.delete(role)
                     flash[:notice] = "The role '#{role.name}' has been revoked from User '#{user.login}'"
                   end
                   redirect_to admin_user_admin_index_path
                 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.'
                     redirect_to :action => 'mass_mailing' and return
                   end
                   mail_body = params[:email_body]
                   if !mail_body or mail_body.blank?
                     flash[:notice] = 'You entered an empty mail body.'
                     redirect_to :action => 'mass_mailing' and return
                   end
                   note = []
                   users = []
                   lines.split("\n").each do |line|
                     user = User.find_by_login(line.chomp)
                     if user
                       send_mail(user.email, mail_subject, mail_body)
                       note << user.login
                     end
                   end
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     ' were successfully modified.  '
                   redirect_to :action => 'mass_mailing'
                 end
                 #bulk manage
                 def bulk_manage
                   begin
-            -       @users = User.where('(login REGEXP ?) OR (remark REGEXP ?)',params[:regex],params[:regex]) if params[:regex]
+            +       if params[:filter_group]
-            -       @users.count if @users #i don't know why I have to call count, but if I won't exception is not raised
+            +         @users = Group.find_by(id: params[:filter_group_id]).users
+            +       else
+            +         @users = User.all
+            +       end
+            +       @users = @users.where('(login REGEXP ?) OR (remark REGEXP ?)',params[:regex],params[:regex]) unless params[:regex].blank?
+            +       @users.count if @users #test the sql
                   rescue Exception
                     flash[:error] = 'Regular Expression is malformed'
                     @users = nil
                   end
                   if params[:commit]
                     @action = {}
                     @action[:set_enable] = params[:enabled]
                     @action[:enabled] = params[:enable] == "1"
                     @action[:gen_password] = params[:gen_password]
                     @action[:add_group] = params[:add_group]
                     @action[:group_name] = params[:group_name]
                   end
                   if params[:commit] == "Perform"
                     if @action[:set_enable]
                       @users.update_all(enabled: @action[:enabled])
                     end
                     if @action[:gen_password]
                       @users.each do |u|
                         password = random_password
                         u.password = password
                         u.password_confirmation = password
                         u.save
                       end
                     end
                     if @action[:add_group] and @action[:group_name]
                       @group = Group.find(@action[:group_name])
                       ok = []
                       failed = []
                       @users.each do |user|
                         begin
                           @group.users << user
                           ok << user.login
                         rescue => e
                           failed << user.login
                         end
                       end
                       flash[:success] = "The following users are added to the 'group #{@group.name}': " + ok.join(', ') if ok.count > 0
                       flash[:alert] = "The following users are already in the 'group #{@group.name}': " + failed.join(', ') if failed.count > 0
                     end
                   end
                 end
                 protected
                 def random_password(length=5)
                   chars = 'abcdefghijkmnopqrstuvwxyz23456789'
                   newpass = ""
                   length.times { newpass << chars[rand(chars.size-1)] }
                   return newpass
                 end
                 def import_from_file(f)
                   data_hash = YAML.load(f)
                   @import_log = ""
                   country_data = data_hash[:countries]
                   site_data = data_hash[:sites]
                   user_data = data_hash[:users]
                   # import country
                   countries = {}
                   country_data.each_pair do |id,country|
                     c = Country.find_by_name(country[:name])
                     if c!=nil
                       countries[id] = c
                       @import_log << "Found #{country[:name]}\n"
                     else
                       countries[id] = Country.new(:name => country[:name])
                       countries[id].save
                       @import_log << "Created #{country[:name]}\n"
                     end
                   end
                   # import sites
                   sites = {}
                   site_data.each_pair do |id,site|
                     s = Site.find_by_name(site[:name])
                     if s!=nil
                       @import_log << "Found #{site[:name]}\n"
                     else
                       s = Site.new(:name => site[:name])
                       @import_log << "Created #{site[:name]}\n"
                     end
                     s.password = site[:password]
                     s.country = countries[site[:country_id]]
                     s.save
                     sites[id] = s
                   end
                   # import users
                   user_data.each_pair do |id,user|
                     u = User.find_by_login(user[:login])
                     if u!=nil
                       @import_log << "Found #{user[:login]}\n"

app/models/group.rb ¶ +7

               class Group < ActiveRecord::Base
                 has_many :groups_problems, class_name: 'GroupProblem'
                 has_many :problems, :through => :groups_problems
                 has_many :groups_users, class_name: 'GroupUser'
                 has_many :users, :through => :groups_users
                 #has_and_belongs_to_many :problems
                 #has_and_belongs_to_many :users
+            +   def add_users_skip_existing(users_list)
+            +     new_list = []
+            +     users_list.each do |u|
+            +       new_list << u unless users.include? u
+            +     end
+            +     users << new_list
+            +   end
               end

app/models/user.rb ¶ +78 -4

                 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?
                   has_role?('admin')
                 end
                 def has_role?(role)
                   self.roles.where(name: role).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
                 # new feature, get list of available problem in all enabled group that the user belongs to
                 def available_problems_in_group
                   problem = []
                   self.groups.where(enabled: true).each do |group|
                     group.problems.where(available: true).each { |p| problem << p }
                   end
                   problem.uniq!
                   if problem
                     problem.sort! do |a,b|
                       case
                       when a.date_added < b.date_added
                       when a.date_added > b.date_added
                         -1
                       else
                         a.name <=> b.name
                       end
                     end
                     return problem
                   else
                     return []
                   end
                 end
                 #check if the user has the right to view that problem
                 #this also consider group based problem policy
                 def can_view_problem?(problem)
                   return true if admin?
                   return available_problems.include? problem
                 end
                 def self.clear_last_login
                   User.update_all(:last_ip => nil)
                 end
+            +   #create multiple user, one per lines of input
+            +   def self.create_from_list(lines)
+            +     error_logins = []
+            +     first_error = nil
+            +     created_users = []
+            +
+            +     lines.split("\n").each do |line|
+            +       #split with large limit, this will cause consecutive ',' to be result in a blank
+            +       items = line.chomp.split(',',1000)
+            +       if items.length>=2
+            +         login = items[0]
+            +         full_name = items[1]
+            +         remark =''
+            +         user_alias = ''
+            +
+            +         added_random_password = false
+            +         added_password = false
+            +
+            +         #given password?
+            +         if items.length >= 3
+            +           if items[2].chomp(" ").length > 0
+            +             password = items[2].chomp(" ")
+            +             added_password = true
+            +           end
+            +         else
+            +           password = random_password
+            +           added_random_password=true;
+            +         end
+            +
+            +         #given alias?
+            +         if items.length>= 4 and items[3].chomp(" ").length > 0;
+            +           user_alias = items[3].chomp(" ")
+            +         else
+            +           user_alias = login
+            +         end
+            +
+            +         #given remark?
+            +         has_remark = false
+            +         if items.length>=5
+            +           remark = items[4].strip;
+            +           has_remark = true
+            +         end
+            +
+            +         user = User.find_by_login(login)
+            +         if (user)
+            +           user.full_name = full_name
+            +           user.remark = remark if has_remark
+            +           user.password = password if added_password || added_random_password
+            +         else
+            +           #create a random password if none are given
+            +           password = random_password unless password
+            +           user = User.new({:login => login,
+            +                            :full_name => full_name,
+            +                            :password => password,
+            +                            :password_confirmation => password,
+            +                            :alias => user_alias,
+            +                            :remark => remark})
+            +         end
+            +         user.activated = true
+            +
+            +         if user.save
+            +           created_users << user
+            +         else
+            +           error_logins << "'#{login}'"
+            +           first_error = user.errors.full_messages.to_sentence unless first_error
+            +         end
+            +       end
+            +     end
+            +
+            +     return {error_logins: error_logins, first_error: first_error, created_users: created_users}
+            +
+            +   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
+            +
                 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/user_admin/bulk_manage.html.haml ¶ +6

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

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

r808:8690f354dd15 - Mon, 09 Aug 2021 16:34:02 - 5 files changed: 111 inserted, 83 deleted

Sign in to your account

Commit r808:8690f354dd15 public

Author

r808:8690f354dd15 - Mon, 09 Aug 2021 16:34:02 - 5 files changed: 111 inserted, 83 deleted

Commit `r808:8690f354dd15` public