cafe-grader-web Commit - r200:3383214a2837

cafe-grader-web

Commit `r200:3383214a2837` public

parent | child

Description:

added random user passwords, better user creation by list. git-svn-id: http://theory.cpe.ku.ac.th/grader/web/trunk@429 6386c4cd-e34a-4fa8-8920-d93eb39b512e

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

r200:3383214a2837 - Sat, 10 Oct 2009 02:36:56 - 5 files changed: 104 inserted, 14 deleted

app/views/user_admin/random_all_passwords.html.haml created 644 ¶ +39

@@ -0,0 +1,39
	1	+ %h1 Random user passwords
	2	+
	3	+ -if @changed
	4	+ %p
	5	+ %b Done!
	6	+ Here's a new password list.
	7	+ Go back to
	8	+ = (link_to '[user list]', :action => 'index') + '.'
	9	+ %br/
	10	+ %table
	11	+ %tr
	12	+ %th Login
	13	+ %th Fullname
	14	+ %th Password
	15	+ -for u in @non_admin_users
	16	+ %tr
	17	+ %td= u.login
	18	+ %td= u.full_name
	19	+ %td
	20	+ %tt= u.password
	21	+
	22	+ -else
	23	+ -if @prefix!=''
	24	+ Current prefix:
	25	+ = @prefix
	26	+ -form_tag((url_for :action => 'random_all_passwords'), :method => 'get') do
	27	+ Change prefix
	28	+ =text_field_tag 'prefix'
	29	+ =submit_tag 'Change'
	30	+
	31	+ This will change passwords of the following users.
	32	+ %ul
	33	+ -for u in @non_admin_users
	34	+ %li= u.login
	35	+
	36	+ -form_tag((url_for :action => 'random_all_passwords'), :method => 'post') do
	37	+ =hidden_field_tag 'prefix', @prefix
	38	+ Are you sure?
	39	+ =submit_tag 'Go ahead'

app/controllers/user_admin_controller.rb ¶ +57 -8

               class UserAdminController < ApplicationController
                 before_filter :admin_authorization
                 def index
                   list
                   render :action => 'list'
                 end
                 # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
-            -   verify :method => :post, :only => [ :destroy, :create, :update ],
+            +   verify :method => :post, :only => [ :destroy,
+            +                                       :create, :create_from_list,
+            +                                       :update ],
                        :redirect_to => { :action => :list }
                 def list
                   @users = User.find(:all)
                   @hidden_columns = ['hashed_password', 'salt', 'created_at', 'updated_at']
                 end
                 def active
                   sessions = ActiveRecord::SessionStore::Session.find(:all, :conditions => ["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(params[:user])
                   @user.activated = true
                   if @user.save
                     flash[:notice] = 'User was successfully created.'
                     redirect_to :action => 'list'
                   else
                     render :action => 'new'
                   end
                 end
                 def create_from_list
                   lines = params[:user_list]
+            +
+            +     note = []
+            +
                   lines.split("\n").each do |line|
                     items = line.chomp.split(',')
-            -       if items.length==4
+            +       if items.length>=2
-            -         user = User.new
+            +         login = items[0]
-            -         user.login = items[0]
+            +         full_name = items[1]
-            -         user.full_name = items[1]
-            -         user.alias = items[2]
+            +         added_random_password = false
-            -         user.password = items[3]
+            +         if items.length>=3
-            -         user.password_confirmation = items[3]
+            +           password = items[2]
+            +           user_alias = (items.length>=4) ? items[3] : login
+            +         else
+            +           password = random_password
+            +           user_alias = (items.length>=4) ? items[3] : login
+            +           added_random_password = true
+            +         end
+            +
+            +         user = User.new({:login => login,
+            +                           :full_name => full_name,
+            +                           :password => password,
+            +                           :password_confirmation => password,
+            +                           :alias => user_alias})
                       user.activated = true
                       user.save
+            +
+            +         if added_random_password
+            +           note << "'#{login}' (+)"
+            +         else
+            +           note << login
                       end
                     end
+            +     end
+            +     flash[:notice] = 'User(s) ' + note.join(', ') +
+            +       ' were successfully created.  ' +
+            +       '( (+) - created with random passwords.)'
                   redirect_to :action => 'list'
                 end
                 def edit
                   @user = User.find(params[:id])
                 end
                 def update
                   @user = User.find(params[:id])
                   if @user.update_attributes(params[:user])
                     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 => 'list'
                 end
                 def user_stat
                   @problems = Problem.find_available_problems
                   @users = User.find(:all)
                   @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)
               	  ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
               	else
               	  ustat << [0,false]
               	end
                     end
                     @scorearray << ustat
                   end
                 end
                 def import
                   if params[:file]==''
                     flash[:notice] = 'Error importing no file'
                     redirect_to :action => 'list' and return
                   end
                   import_from_file(params[:file])
                 end
+            +   def random_all_passwords
+            +     users = User.find(:all)
+            +     @prefix = params[:prefix] || ''
+            +     @non_admin_users = User.find_non_admin_with_prefix(@prefix)
+            +     @changed = false
+            +     if request.request_method == :post
+            +       @non_admin_users.each do |user|
+            +         password = random_password
+            +         user.password = password
+            +         user.password_confirmation = password
+            +         user.save
+            +       end
+            +       @changed = true
+            +     end
+            +   end
+            +
                 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"
                     else
                       u = User.new(:login => user[:login])
                       @import_log << "Created #{user[:login]}\n"
                     end
                     u.full_name = user[:name]
                     u.password = user[:password]
                     u.country = countries[user[:country_id]]
                     u.site = sites[user[:site_id]]
                     u.activated = true
                     u.email = "empty-#{u.login}@none.com"
                     if not u.save
                       @import_log << "Errors\n"
                       u.errors.each { |attr,msg|  @import_log << "#{attr} - #{msg}\n" }
                     end
                   end
                 end
               end

app/models/user.rb ¶ +5

                 belongs_to :country
                 named_scope :activated_users, :conditions => {:activated => true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /^[\_A-Za-z0-9]+$/
                 validates_length_of :login, :within => 3..30
                 validates_presence_of :full_name
                 validates_length_of :full_name, :minimum => 1
                 validates_presence_of :password, :if => :password_required?
                 validates_length_of :password, :within => 4..20, :if => :password_required?
                 validates_confirmation_of :password, :if => :password_required?
                 validates_format_of :email,
                                     :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i,
                                     :if => :email_validation?
                 validate :uniqueness_of_email_from_activated_users,
                          :if => :email_validation?
                 validate :enough_time_interval_between_same_email_registrations,
                          :if => :email_validation?
                 # these are for ytopc
                 # disable for now
                 #validates_presence_of :province
                 attr_accessor :password
                 before_save :encrypt_new_password
                 before_save :assign_default_site
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   return user if user && user.authenticated?(password)
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def admin?
                   self.roles.detect {|r| r.name == 'admin' }
                 end
                 def email_for_editing
                   if self.email==nil
                     "(unknown)"
                   elsif self.email==''
                     "(blank)"
                   else
                     self.email
                   end
                 end
                 def email_for_editing=(e)
                   self.email=e
                 end
                 def alias_for_editing
                   if self.alias==nil
                     "(unknown)"
                   elsif self.alias==''
                     "(blank)"
                   else
                     self.alias
                   end
                 end
                 def alias_for_editing=(e)
                   self.alias=e
                 end
                 def activation_key
                   if self.hashed_password==nil
                     encrypt_new_password
                   end
                   Digest::SHA1.hexdigest(self.hashed_password)[0..7]
                 end
                 def verify_activation_key(key)
                   key == activation_key
                 end
                 def self.random_password(length=5)
                   chars = 'abcdefghjkmnopqrstuvwxyz'
                   password = ''
                   length.times { password << chars[rand(chars.length - 1)] }
                   password
                 end
+            +   def self.find_non_admin_with_prefix(prefix='')
+            +     users = User.find(:all)
+            +     return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
+            +   end
+            +
                 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 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_to_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_to_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/list.rhtml ¶ +1

               <h1>Listing users</h1>
               <div class="submitbox">
               <b>Quick add</b>
               <% form_tag :action => 'create' do %>
                 <table border="0">
                 <tr>
                 <td><label for="user_login">Login</label></td>
                 <td><label for="user_full_name">Full name</label></td>
                 <td><label for="user_password">Password</label></td>
                 <td><label for="user_password_confirmation">Confirm</label></td>
                 <td><label for="user_email">Email</label></td>
                 </tr>
                 <tr>
                 <td><%= text_field 'user', 'login', :size => 10  %></td>
                 <td><%= text_field 'user', 'full_name', :size => 30  %></td>
                 <td><%= password_field 'user', 'password', :size => 10  %></td>
                 <td><%= password_field 'user', 'password_confirmation', :size => 10 %></td>
                 <td><%= text_field 'user', 'email', :size => 15 %></td>
                 <td><%= submit_tag "Create" %></td>
                 </tr></table>
               <% end %>
               <br/>
               <b>Import from site management</b>
               <% form_tag({:action => 'import'}, :multipart => true) do %>
                 File: <%= file_field_tag 'file' %> <%= submit_tag 'Import' %>
               <% end %>
               <br/>
               <b>What else: </b>
               <%= link_to '[New user]', :action => 'new' %>
               <%= link_to '[New list of users]', :action => 'new_list' %>
+            + <%= link_to '[Random passwords]', :action => 'random_all_passwords' %>
               <%= link_to '[View active users]', :action => 'active' %>
               </div>
               <table>
                 <tr>
                 <% for column in User.content_columns %>
                   <% if !@hidden_columns.index(column.name) %>
                     <th><%= column.human_name %></th>
                   <% end %>
                 <% end %>
                 </tr>
               <% for user in @users %>
                 <tr>
                 <% for column in User.content_columns %>
                   <% if !@hidden_columns.index(column.name) %>
                     <td><%=h user.send(column.name) %></td>
                   <% end %>
                 <% end %>
                   <td><%= link_to 'Show', :action => 'show', :id => user %></td>
                   <td><%= link_to 'Edit', :action => 'edit', :id => user %></td>
                   <td><%= link_to 'Destroy', { :action => 'destroy', :id => user }, :confirm => 'Are you sure?', :method => :post %></td>
                 </tr>
               <% end %>
               </table>
               <br />
               <%= link_to 'New user', :action => 'new' %>
               <%= link_to 'New list of users', :action => 'new_list' %>

app/views/user_admin/new_list.rhtml ¶ +2 -6

               <h1>Adding list of users</h1>
-            - <div class="usermenu">
-            - <%= link_to 'User admin', :action => 'list' %>
-            - <%= link_to 'Main', :controller => 'main', :action => 'list' %>
-            - </div>
               <% form_tag :action => 'create_from_list' do %>
               <%= submit_tag 'create users' %><br/>
-            - List of user information: user_id,name,alias,passwd<br/>
+            + List of user information in this format: <tt>user_id,name(,passwd(,alias))</tt><br/>
+            + Note that <tt>passwd</tt> and <tt>alias</tt> is optional.<br/>
               <%= text_area_tag 'user_list', nil, :rows => 50, :cols => 80 %>
               <% end %>

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

r200:3383214a2837 - Sat, 10 Oct 2009 02:36:56 - 5 files changed: 104 inserted, 14 deleted

Sign in to your account

Commit r200:3383214a2837 public

Author

r200:3383214a2837 - Sat, 10 Oct 2009 02:36:56 - 5 files changed: 104 inserted, 14 deleted

Commit `r200:3383214a2837` public