cafe-grader-web Commit - r846:4279bf26f98b

cafe-grader-web

Commit `r846:4279bf26f98b` public

parent | child

Description:

fix wrong merge

Commit status:

[Not Reviewed]

References:

algo

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r846:4279bf26f98b - Tue, 10 Aug 2021 16:55:42 - 1 file changed: 78 inserted, 5 deleted

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

                 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
                     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

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

r846:4279bf26f98b - Tue, 10 Aug 2021 16:55:42 - 1 file changed: 78 inserted, 5 deleted

Sign in to your account

Commit r846:4279bf26f98b public

Author

r846:4279bf26f98b - Tue, 10 Aug 2021 16:55:42 - 1 file changed: 78 inserted, 5 deleted

Commit `r846:4279bf26f98b` public