Rcov C0 Coverage Information - RCov

 class MainController < ApplicationController

   include MainHelper

   protect_from_forgery :except => [:login, :page_not_found]

   before_filter      :authorize_for_user,

   before_filter :authorize_only_for_admin, :only => [:login_as]

   def login

     # external auth has been done, skip markus authorization

     if MarkusConfigurator.markus_config_remote_user_auth

       if @markus_auth_remote_user.nil?

         login_success = login_without_authentication(@markus_auth_remote_user)

         if login_success

           uri = session[:redirect_uri]

           session[:redirect_uri] = nil

           refresh_timeout

           current_user.set_api_key # set api key in DB for user if not yet set

           redirect_to( uri || { :action => 'index' } )

           return

     @current_user = current_user

     # redirect to main page if user is already logged in.

     if logged_in? && !request.post?

       redirect_to :action => 'index'

       return

     end

     return unless request.post?

     # strip username

     params[:user_login].strip!

     # Get information of the user that is trying to login if his or her

     # authentication is valid

     validation_result = validate_user(params[:user_login], params[:user_login], params[:user_password])

     if !validation_result[:error].nil?

       flash[:login_notice] = validation_result[:error]

       redirect_to :action => 'login'

       return

     end

     # validation worked

     found_user = validation_result[:user]

     if found_user.nil?

     end

     if found_user.student? && found_user.hidden

       redirect_to(:action => 'login') && return

     self.current_user = found_user

     if logged_in?

       uri = session[:redirect_uri]

       session[:redirect_uri] = nil

       refresh_timeout

       current_user.set_api_key # set api key in DB for user if not yet set

       redirect_to( uri || { :action => 'index' } )

   def logout

     logout_redirect = MarkusConfigurator.markus_config_logout_redirect

     if logout_redirect == "NONE"

       page_not_found

     end

     m_logger = MarkusLogger.instance

     # The real_uid field of session keeps track of the uid of the original

     # user that is logged in if there is a role switch

     if !session[:real_uid].nil? && !session[:uid].nil?

       #An admin was logged in as a student or grader

       m_logger.log("User '#{current_user.user_name}' logged out.")

     clear_session

     cookies.delete :auth_token

     reset_session

     if logout_redirect == 'DEFAULT'

       redirect_to :action => 'login'

       return

       redirect_to logout_redirect

       return

     end

   end

   def index

     @current_user = current_user

     if @current_user.student? or @current_user.ta?

       redirect_to :controller => 'assignments', :action => 'index'

       return

   def about

     # dummy action for remote rjs calls

     # triggered by clicking on the about icon

   end

   def reset_api_key

     render :file => "#{::Rails.root.to_s}/public/404.html", :status => 404 and return unless request.post?

     if !@current_user.student?

       @current_user.reset_api_key

       @current_user.save

     else

       render :file => "#{::Rails.root.to_s}/public/404.html", :status => 404 and return

     render :action => 'api_key_replace', :locals => {:user => @current_user }

   end

   # Render 404 error (page not found) if no other route matches.

   # See config/routes.rb

   def page_not_found

     render :file => "#{::Rails.root.to_s}/public/404.html", :status => 404

   end

   # Authenticates the admin (i.e. validates her password). Given the user, that

   # desired user on success.

   # form, grant the current user (an admin) access to the account of the user

   #

   #   role_switch_handler

   #   role_switch_content

   def login_as

     validation_result = nil

     if MarkusConfigurator.markus_config_remote_user_auth

       validation_result = validate_user_without_login(params[:effective_user_login],

                                         params[:user_login])

       validation_result = validate_user(params[:effective_user_login],

                                         params[:user_login],

                                         params[:admin_password])

     if !validation_result[:error].nil?

         :locals => { :error => validation_result[:error], :success => false }

       return

     found_user = validation_result[:user]

     if found_user.nil?

     if found_user.admin?

             { :error => I18n.t(:cannot_login_as_another_admin), :success => false }

       return

     m_logger = MarkusLogger.instance

     m_logger.log("Admin '#{current_user.user_name}' logged in as '#{params[:effective_user_login]}'.")

     session[:real_uid] = session[:uid]

     self.current_user = found_user

     if logged_in?

       uri = session[:redirect_uri]

       session[:redirect_uri] = nil

       refresh_timeout

       current_user.set_api_key # set api key in DB for user if not yet set

             { :success => true }

       return

   def role_switch

   def clear_role_switch_session

     m_logger = MarkusLogger.instance

     if !session[:real_uid].nil? && !session[:uid].nil?

       m_logger.log("WARNING: Possible break in attempt from '#{current_user.user_name}'.")

     clear_session

     cookies.delete :auth_token

     reset_session

     redirect_to :action => 'login'

     return

 private

   def login_without_authentication(markus_auth_remote_user)

     found_user = User.authorize(markus_auth_remote_user)

     if found_user.nil?

     if found_user.student? && found_user.hidden

     if found_user.admin? && !session[:real_uid].nil? &&

       self.current_user = found_user

     if logged_in?

       return true

   def validate_user(effective_user, real_user, password)

     validation_result = Hash.new

     validation_result[:user] = nil # Let's be explicit

     blank_login = effective_user.blank?

     blank_pwd = password.blank?

     validation_result[:error] = get_blank_message(blank_login, blank_pwd)

     return validation_result if blank_login || blank_pwd

     authenticate_response = User.authenticate(real_user,

     if authenticate_response == User::AUTHENTICATE_BAD_PLATFORM

     if authenticate_response == User::AUTHENTICATE_SUCCESS

       found_user = User.authorize(effective_user)

       if found_user.nil?

         validation_result[:error] = I18n.t(:login_failed)

         return validation_result

     validation_result[:error] = nil

     validation_result[:user] = found_user

     return validation_result

   def validate_user_without_login(effective_user, real_user)

     validation_result = Hash.new

     validation_result[:user] = nil # Let's be explicit

     blank_login = effective_user.blank?

     validation_result[:error] = get_blank_message(blank_login, false)

     return validation_result if blank_login

     found_user = User.authorize(effective_user)

     if found_user.nil?

     validation_result[:error] = nil

     validation_result[:user] = found_user

     return validation_result