Rcov C0 Coverage Information - RCov

 require 'fastercsv'

 require 'digest' # required for {set,reset}_api_token

 require 'base64' # required for {set,reset}_api_token

 require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'repo', 'repository')

 class User < ActiveRecord::Base

   before_validation :strip_name

   has_many :memberships

   has_many :groupings, :through => :memberships

   has_many :notes, :as => :noteable, :dependent => :destroy

   has_many :accepted_memberships, :class_name => "Membership", :conditions => {:membership_status => [StudentMembership::STATUSES[:accepted], StudentMembership::STATUSES[:inviter]]}

   validates_presence_of     :user_name, :last_name, :first_name

   validates_uniqueness_of   :user_name

   validates_format_of       :type,          :with => /Student|Admin|Ta/

   STUDENT = 'Student'

   ADMIN = 'Admin'

   TA = 'Ta'

   AUTHENTICATE_SUCCESS =      0   # valid username/password combination

   AUTHENTICATE_NO_SUCH_USER = 1   # user does not exist

   AUTHENTICATE_BAD_PASSWORD = 2   # wrong password

   AUTHENTICATE_ERROR =        3   # generic/unknown error

   AUTHENTICATE_BAD_CHAR =     4   # invalid character in username/password

   AUTHENTICATE_BAD_PLATFORM = 5   # external authentication works for *NIX platforms only

   def self.authorize(login)

     find_by_user_name(login)

   def self.authenticate(login, password)

     not_allowed_regexp = Regexp.new(/[\n\0]+/)

     if !(not_allowed_regexp.match(login) || not_allowed_regexp.match(password))

       if RUBY_PLATFORM =~ /(:?mswin|mingw)/ # should match for Windows only

       pipe = IO.popen( MarkusConfigurator.markus_config_validate_file, "w+" )

       pipe.puts("#{login}\n#{password}") # write to stdin of markus_config_validate

       pipe.close

       m_logger = MarkusLogger.instance

       case $?.exitstatus

         when 0

           m_logger.log("User '#{login}' logged in.", MarkusLogger::INFO)

           return AUTHENTICATE_SUCCESS

   # they'll be slow in production

   def active_groupings

     self.groupings.find(:all, :conditions => ["memberships.membership_status != :u", { :u => StudentMembership::STATUSES[:rejected]}])

   def admin?

     self.class == Admin

   def ta?

     self.class == Ta

   def student?

     self.class == Student

   def submission_for(aid)

   # Classlist parsing --------------------------------------------------------

   def self.generate_csv_list(user_list)

          end

          csv << user_array

        end

      end

      return file_out

   end

   def self.upload_user_list(user_class, user_list)

     num_update = 0

     result = {}

     result[:invalid_lines] = []  # store lines that were not processed

     # read each line of the file and update classlist

     User.transaction do

       processed_users = []

       FasterCSV.parse(user_list, :skip_blanks => true, :row_sep => :auto) do |row|

         next if FasterCSV.generate_line(row).strip.empty?

         if processed_users.include?(row[0])

           result[:invalid_lines] = I18n.t('csv_upload_user_duplicate', {:user_name => row[0]})

           if User.add_user(user_class, row).nil?

             result[:invalid_lines] << row.join(",")

           else

             num_update += 1

             processed_users.push(row[0])

         end

       end # end prase

     result[:upload_notice] = "#{num_update} user(s) added/updated."

     return result

   end

   def self.add_user(user_class, row)

     # convert each line to a hash with FIELDS as corresponding keys

     # and create or update a user with the hash values

     #return nil if values.length < UPLOAD_FIELDS.length

     user_attributes = {}

     user_class::CSV_UPLOAD_ORDER.zip(row) do |key, val|

       # append them to the hash that is returned by User.get_default_ta/student_attrs

       # remove the section if the user has one

       if key == :section_name

         if !val.nil?

           section = Section.find_or_create_by_name(val)

           user_attributes["section_id"] = section.id

         user_attributes[key] = val

       end

     end

     # Is there already a Student with this User number?

     current_user = user_class.find_or_create_by_user_name(user_attributes[:user_name])

     current_user.attributes = user_attributes

     if !current_user.save

       return nil

     return current_user

   def self.repo_config

     # create config

     conf = Hash.new

     conf["IS_REPOSITORY_ADMIN"] = MarkusConfigurator.markus_config_repository_admin?

     conf["REPOSITORY_PERMISSION_FILE"] = MarkusConfigurator.markus_config_repository_permission_file

     return conf

   end

   # Set API key for user model. The key is a

   # SHA2 512 bit long digest, which is in turn

   # MD5 digested and Base64 encoded so that it doesn't

   # include bad HTTP characters.

   # token should be automatically generated.

   def set_api_key

     if self.api_key.nil?

       key = generate_api_key

       md5 = Digest::MD5.new

       md5.update(key)

       # base64 encode md5 hash

       self.api_key = Base64.encode64(md5.to_s).strip

       return self.save

     else

       return true

   end

   # Resets the api key. Usually triggered, if the

   # old md5 hash has gotten into the wrong hands.

   def reset_api_key

     key = generate_api_key

     md5 = Digest::MD5.new

     md5.update(key)

     # base64 encode md5 hash

     self.api_key = Base64.encode64(md5.to_s).strip

     return self.save

   end

   private

   # Create some random, hard to guess SHA2 512 bit long

   # digest.

   def generate_api_key

     digest = Digest::SHA2.new(bitlen=512)

     unique_seed = ActiveSupport::SecureRandom.hex(20)

     return digest.update("#{unique_seed} SECRET! #{Time.now.to_f}").to_s

   end

   # strip input string

   def strip_name

     if !self.user_name.nil?

       self.user_name.strip!

     end

     if !self.last_name.nil?

       self.last_name.strip!

     if !self.first_name.nil?

       self.first_name.strip!

     end

   end

   # Adds read and write permissions for each newly created Admin or Ta user

   def grant_repository_permissions

     # If we're not the repository admin, bail out

     return if(self.student? or !MarkusConfigurator.markus_config_repository_admin?)

     conf = User.repo_config

     repo = Repository.get_class(MarkusConfigurator.markus_config_repository_type,

                                 conf)

     repo_names = Group.all.collect do |group|

                    File.join(MarkusConfigurator.markus_config_repository_storage,

                              group.repository_name)

     repo.set_bulk_permissions(repo_names, {self.user_name => Repository::Permission::READ_WRITE})

   end

   # Revokes read and write permissions for a deleted admin user

   def revoke_repository_permissions

     return if(self.student? or !MarkusConfigurator.markus_config_repository_admin?)

     conf = User.repo_config

     repo = Repository.get_class(MarkusConfigurator.markus_config_repository_type, conf)

     repo_names = Group.all.collect do |group| File.join(MarkusConfigurator.markus_config_repository_storage, group.repository_name) end

     repo.delete_bulk_permissions(repo_names, [self.user_name])

   end

   def maintain_repository_permissions

     return if(self.student? or !MarkusConfigurator.markus_config_repository_admin?)

     if self.user_name_changed?