cafe-grader-web Commit - r160:0138848b0c5b

cafe-grader-web

Commit `r160:0138848b0c5b` public

parent | child

Description:

fixed user confirmation bug git-svn-id: http://theory.cpe.ku.ac.th/grader/web/trunk@305 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

r160:0138848b0c5b - Thu, 11 Dec 2008 04:05:51 - 5 files changed: 23 inserted, 12 deleted

app/controllers/main_controller.rb ¶ +14 -6

               class MainController < ApplicationController
                 SYSTEM_MODE_CONF_KEY = 'system.mode'
                 before_filter :authenticate, :except => [:index, :login]
                 before_filter :check_viewability, :except => [:index, :login]
-            - #
+            +   # COMMENTED OUT: filter in each action instead
-            - #  COMMENT OUT: filter in each action instead
-            - #
                 # before_filter :verify_time_limit, :only => [:submit]
                 verify :method => :post, :only => [:submit],
                        :redirect_to => { :action => :index }
-            - #  COMMENT OUT, only need when having high load
+            +   # COMMENT OUT: only need when having high load
                 # caches_action :index, :login
+            +   # NOTE: This method is not actually needed, 'config/routes.rb' has
+            +   # assigned action login as a default action.
                 def index
                   redirect_to :action => 'login'
                 end
                 def login
                   saved_notice = flash[:notice]
                   reset_session
                   flash[:notice] = saved_notice
+            +     # EXPERIMENT:
+            +     # Hide login if in single user mode and the url does not
+            +     # explicitly specify /login
                   #
-            -     # These are for site administrator login
+            +     # logger.info "PATH: #{request.path}"
-            -     #
+            +     # if Configuration['system.single_user_mode'] and
+            +     #     request.path!='/main/login'
+            +     #   @hidelogin = true
+            +     # end
+            +
+            +     # Site administrator login
                   @countries = Country.find(:all, :include => :sites)
                   @country_select = @countries.collect { |c| [c.name, c.id] }
                   @country_select_with_all = [['Any',0]]
                   @countries.each do |country|
                     @country_select_with_all << [country.name, country.id]
                   end
                   @site_select = []
                   @countries.each do |country|
                     country.sites.each do |site|
                       @site_select << ["#{site.name}, #{country.name}", site.id]
                     end
                   end
                   @announcements = Announcement.find_for_frontpage
                   render :action => 'login', :layout => 'empty'
                 end
                 def list
                   prepare_list_information
                 end
                 def help
                   @user = User.find(session[:user_id])
                 end
                 def submit
                   user = User.find(session[:user_id])
                   @submission = Submission.new(params[:submission])
                   @submission.user = user
                   @submission.language_id = 0
                   if params['file']!=''
                     @submission.source = params['file'].read
                     @submission.source_filename = params['file'].original_filename
                   end
                   @submission.submitted_at = Time.new.gmtime
                   if Configuration[SYSTEM_MODE_CONF_KEY]=='contest' and
                       user.site!=nil and user.site.finished?
                     @submission.errors.add_to_base "The contest is over."
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   if @submission.valid?
                     if @submission.save == false
               	flash[:notice] = 'Error saving your submission'
                     elsif Task.create(:submission_id => @submission.id,
                                       :status => Task::STATUS_INQUEUE) == false
               	flash[:notice] = 'Error adding your submission to task queue'
                     end
                   else
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   redirect_to :action => 'list'
                 end
                 def source
                   submission = Submission.find(params[:id])
                   if submission.user_id == session[:user_id]
                     if submission.problem.output_only
                       fname = submission.source_filename
                     else
                       fname = submission.problem.name + '.' + submission.language.ext
                     end
                     send_data(submission.source,
               		{:filename => fname,
                                 :type => 'text/plain'})
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def compiler_msg
                   @submission = Submission.find(params[:id])
                   if @submission.user_id == session[:user_id]
                     render :action => 'compiler_msg', :layout => 'empty'
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def submission
                   @user = User.find(session[:user_id])
                   @problems = Problem.find_available_problems
                   if params[:id]==nil
                     @problem = nil
                     @submissions = nil
                   else
                     @problem = Problem.find_by_name(params[:id])
                     if not @problem.available
                       redirect_to :action => 'list'
                       flash[:notice] = 'Error: submissions for that problem are not viewable.'
                       return
                     end
                     @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id)
                   end
                 end
                 def result
                   if !Configuration.show_grading_result
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   prepare_grading_result(@submission)
                 end
                 def load_output
                   if !Configuration.show_grading_result or params[:num]==nil
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   case_num = params[:num].to_i
                   out_filename = output_filename(@user.login,
                                                  @submission.problem.name,
                                                  @submission.id,
                                                  case_num)
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   response.headers['Content-Type'] = "application/force-download"
                   response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
                   response.headers["X-Sendfile"] = out_filename
                   response.headers['Content-length'] = File.size(out_filename)
                   render :nothing => true
                 end
                 def error
                   @user = User.find(session[:user_id])
                 end
                 protected
                 def prepare_list_information
                   @problems = Problem.find_available_problems
                   @prob_submissions = Array.new
                   @user = User.find(session[:user_id])
                   @problems.each do |p|
                     sub = Submission.find_last_by_user_and_problem(@user.id,p.id)
                     if sub!=nil
                       @prob_submissions << { :count => sub.number, :submission => sub }
                     else
                       @prob_submissions << { :count => 0, :submission => nil }
                     end
                   end
                   @announcements = Announcement.find_published
                 end
                 def check_viewability
                   @user = User.find(session[:user_id])
                   if (!Configuration.show_tasks_to?(@user)) and
                       ((action_name=='submission') or (action_name=='submit'))
                     redirect_to :action => 'list' and return
                   end
                 end
                 def prepare_grading_result(submission)
                   grading_info = Configuration.task_grading_info[submission.problem.name]
                   @test_runs = []
                   if grading_info['testruns'].is_a? Integer
                     trun_count = grading_info['testruns']
                     trun_count.times do |i|
                       @test_runs << [ read_grading_result(@user.login,
                                                           submission.problem.name,
                                                           submission.id,
                                                           i+1) ]
                     end
                   else
                     grading_info['testruns'].keys.sort.each do |num|
                       run = []
                       testrun = grading_info['testruns'][num]
                       testrun.each do |c|
                         run << read_grading_result(@user.login,
                                                    submission.problem.name,
                                                    submission.id,
                                                    c)

app/controllers/users_controller.rb ¶ +5 -5

               require 'tmail'
               require 'net/smtp'
               class UsersController < ApplicationController
                 before_filter :authenticate, :except => [:new, :register, :confirm]
                 verify :method => :post, :only => [:chg_passwd],
                        :redirect_to => { :action => :index }
                 in_place_edit_for :user, :alias_for_editing
                 in_place_edit_for :user, :email_for_editing
                 def index
                   if !Configuration['system.user_setting_enabled']
                     redirect_to :controller => 'main', :action => 'list'
                   else
                     @user = User.find(session[:user_id])
                   end
                 end
                 def chg_passwd
                   user = User.find(session[:user_id])
                   user.password = params[:passwd]
                   user.password_confirmation = params[:passwd_verify]
                   if user.save
                     flash[:notice] = 'password changed'
                   else
                     flash[:notice] = 'Error: password changing failed'
                   end
                   redirect_to :action => 'index'
                 end
                 def new
                   @user = User.new
                   render :action => 'new', :layout => 'empty'
                 end
                 def register
                   @user = User.new(params[:user])
                   @user.password_confirmation = @user.password = User.random_password
                   @user.activated = false
                   if (@user.valid?) and (@user.save)
                     if send_confirmation_email(@user)
                       render :action => 'new_splash', :layout => 'empty'
                     else
                       render :action => 'email_error', :layout => 'empty'
                     end
                   else
                     @user.errors.add_to_base("Email cannot be blank") if @user.email==''
                     render :action => 'new', :layout => 'empty'
                   end
                 end
                 def confirm
                   login = params[:login]
                   key = params[:activation]
-            -     user = User.find_by_login(login)
+            +     @user = User.find_by_login(login)
-            -     if (user) and (user.verify_activation_key(key))
+            +     if (@user) and (@user.verify_activation_key(key))
-            -       if user.valid?  # check uniquenss of email
+            +       if @user.valid?  # check uniquenss of email
-            -         user.activated = true
+            +         @user.activated = true
-            -         user.save
+            +         @user.save
                       @result = :successful
                     else
                       @result = :email_used
                     end
                   else
                     @result = :failed
                   end
                   render :action => 'confirm', :layout => 'empty'
                 end
                 protected
                 def send_confirmation_email(user)
                   contest_name = Configuration['contest.name']
                   activation_url = url_for(:action => 'confirm',
                                            :login => user.login,
                                            :activation => user.activation_key)
                   home_url = url_for(:controller => 'main', :action => 'index')
                   mail = TMail::Mail.new
                   mail.to = user.email
                   mail.from = Configuration['system.online_registration.from']
                   mail.subject = "[#{contest_name}] Confirmation"
                   mail.body = <<-EOF
               Hello #{user.full_name},
               You have registered for #{contest_name} (#{home_url}).
               Your login is: #{user.login}
               Your password is: #{user.password}
               Please follow the link:
               #{activation_url}
               to activate your user account.
               If you did not register, please ignore this e-mail.
               Thanks!
               EOF
                   smtp_server = Configuration['system.online_registration.smtp']
                   begin
                     Net::SMTP.start(smtp_server) do |smtp|
                       smtp.send_message(mail.to_s, mail.from, mail.to)
                     end
                     result = true
                   rescue
                     result = false
                   end
                   return result
                 end
               end

app/models/user.rb ¶ +1

               require 'digest/sha1'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
                 has_many :test_requests, :order => "submitted_at DESC"
                 has_many :messages,
                          :class_name => "Message",
                          :foreign_key => "sender_id",
                          :order => 'created_at DESC'
                 has_many :replied_messages,
                          :class_name => "Message",
                          :foreign_key => "receiver_id",
                          :order => 'created_at DESC'
                 belongs_to :site
                 belongs_to :country
                 named_scope :activated_users, :conditions => {:activated => true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /^[\_a-z0-9]+$/
                 validates_length_of :login, :within => 3..10
                 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, :allow_blank => true
                 validate :uniqueness_of_email_from_activated_users
                 validate :enough_time_interval_between_same_email_registrations
                 attr_accessor :password
                 before_save :encrypt_new_password
                 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
                 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 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?
                     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
               end

app/views/main/login.html.haml ¶ +2 -1

               %h1= Configuration['ui.front.title']
               - if @announcements.length!=0
                 .announcementbox
                   %span{:class => 'title'}
                     Announcements
                   = render :partial => 'announcement', :collection => @announcements
               %b= Configuration['ui.front.welcome_message']
               %br/
+            +
+            + - if !@hidelogin
                 Please login to see the problem list.
                 %br/
                 %br/
                 - if flash[:notice]
                   %hr/
                   %b= flash[:notice]
                   %hr/
                 %div{ :style => "border: solid 1px gray; padding: 2px; background: #f0f0f0;"}
                   - form_tag :controller => 'login', :action => 'login' do
                     %table
                       %tr
                         %td{:align => "right"} Login:
                         %td= text_field_tag 'login'
                       %tr
                         %td{:align => "right"} Password:
                         %td= password_field_tag
                     = submit_tag 'Login'
               %br/
               - if Configuration['system.online_registration']
                 Want to participate?
                 %b
                   Please
                   = link_to 'register.', :controller => :users, :action => :new
                 %br/
               - if (Configuration['system.mode']=='contest') and (Configuration['contest.multisites'])
                 %script{:type => 'text/javascript'}
                   var siteList = new Array();
                   - @countries.each do |country|
                     = "siteList[#{country.id}] = new Array();"
                     - country.sites.each do |site|
                       = "siteList[#{country.id}][#{site.id}] = \"#{site.name}\";"
                   var allSiteList = new Array();
                   - @site_select.each do |sel|
                     = "allSiteList[#{sel[1]}]=\"#{sel[0]}\";"
                 %script{:type => 'text/javascript', :src => '/javascripts/site_update.js'}
                 %div{ :style => "border: solid 1px gray; padding: 2px; background: #f0f0f0;"}
                   %b For Site Administrator.
                   %br/
                   Please select your country and site and login.
                   - form_for :login, nil, :url => {:controller => 'login', :action => 'site_login'} do |f|
                     Country:
                     = select :site_country, :id, @country_select_with_all, {}, {:onchange => "updateSiteList();", :onclick => "updateSiteList();" }
                     Site:
                     = select :login, :site_id, @site_select
                     %br/
                     Password:
                     = f.password_field :password
                     = submit_tag "Site Administrator Login"
                 %script{:type => 'text/javascript'}
                   updateSiteList();

spec/controllers/users_controller_spec.rb ¶ +1

               require File.dirname(__FILE__) + '/../spec_helper'
               describe UsersController, "when a new user registers" do
                 before(:each) do
                   # create john
                   @john_info = {:login => 'john',
                     :full_name => 'John John',
                     :email => 'john@space.com'}
                   @john = User.new(@john_info)
                   @john_activation_key = "123456"
                   @john.should_receive(:activation_key).
                     any_number_of_times.
                     and_return(@john_activation_key)
                   get :new
                   response.should render_template('users/new')
                 end
                 it "should show the new form again when user information is invalid" do
                   User.should_receive(:new).with(any_args()).and_return(@john)
                   @john.should_receive(:activated=).with(false)
                   @john.should_receive(:valid?).and_return(false)
                   @john.should_not_receive(:save)
                   post :register, :login => @john_info[:login],
                                   :full_name => @john_info[:full_name],
                                   :email => @john_info[:email]
                   response.should render_template('users/new')
                 end
                 it "should create unactivated user and send e-mail with activation key" do
                   User.should_receive(:new).with(any_args()).and_return(@john)
                   @john.should_receive(:activated=).with(false)
                   @john.should_receive(:valid?).and_return(true)
                   @john.should_receive(:save).and_return(true)
                   smtp_mock = mock("smtp")
                   smtp_mock.should_receive(:send_message) do |msg,fr,to|
                     to.should == [@john_info[:email]]
                     msg.index(@john_activation_key).should_not be_nil
                   end
                   Net::SMTP.should_receive(:start).
                     with(any_args()).
                     and_yield(smtp_mock)
                   post :register, :login => @john_info[:login],
                                   :full_name => @john_info[:full_name],
                                   :email => @john_info[:email]
                   response.should render_template('users/new_splash')
                 end
                 it "should create unactivated user and return error page when e-mail sending error" do
                   User.should_receive(:new).with(any_args()).and_return(@john)
                   @john.should_receive(:activated=).with(false)
                   @john.should_receive(:valid?).and_return(true)
                   @john.should_receive(:save).and_return(true)
                   smtp_mock = mock("smtp")
                   smtp_mock.should_receive(:send_message).
                     and_throw(:error)
                   Net::SMTP.should_receive(:start).
                     with(any_args()).
                     and_yield(smtp_mock)
                   post :register, :login => @john_info[:login],
                                   :full_name => @john_info[:full_name],
                                   :email => @john_info[:email]
                   response.should render_template('users/email_error')
                 end
                 it "should activate user with valid activation key" do
                   login = @john_info[:login]
                   User.should_receive(:find_by_login).
                     with(login).
                     and_return(@john)
+            +     User.should_not_receive(:find_by_email)
                   @john.should_receive(:valid?).and_return(true)
                   @john.should_receive(:activated=).with(true)
                   @john.should_receive(:save).and_return(true)
                   get :confirm, :login => login, :activation => @john_activation_key
                   response.should render_template('users/confirm')
                 end
               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

r160:0138848b0c5b - Thu, 11 Dec 2008 04:05:51 - 5 files changed: 23 inserted, 12 deleted

Sign in to your account

Commit r160:0138848b0c5b public

Author

r160:0138848b0c5b - Thu, 11 Dec 2008 04:05:51 - 5 files changed: 23 inserted, 12 deleted

Commit `r160:0138848b0c5b` public