cafe-grader-web Commit - r689:124074894d4b

cafe-grader-web

Commit `r689:124074894d4b` public

parent | child

Description:

commited

Commit status:

[Not Reviewed]

References:

merge java

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r689:124074894d4b - Wed, 13 Sep 2017 10:45:07 - 16 files changed: 106 inserted, 21 deleted

app/assets/javascripts/groups.js.coffee created 644 ¶

new file 100644

app/assets/javascripts/testcases.js.coffee created 644 ¶

new file 100644

app/assets/stylesheets/groups.css.scss created 644 ¶

new file 100644

app/assets/stylesheets/testcases.css.scss created 644 ¶

new file 100644

app/models/group_problem.rb created 644 ¶ +7

@@ -0,0 +1,7
	1	+ class GroupProblem < ActiveRecord::Base
	2	+ self.table_name = 'groups_problems'
	3	+
	4	+ belongs_to :problem
	5	+ belongs_to :group
	6	+ validates_uniqueness_of :problem_id, scope: :group_id, message: ->(object, data) { "'#{Problem.find(data[:value]).full_name}' is already in the group" }
	7	+ end

app/models/group_user.rb created 644 ¶ +7

@@ -0,0 +1,7
	1	+ class GroupUser < ActiveRecord::Base
	2	+ self.table_name = 'groups_users'
	3	+
	4	+ belongs_to :user
	5	+ belongs_to :group
	6	+ validates_uniqueness_of :user_id, scope: :group_id, message: ->(object, data) { "'#{User.find(data[:value]).full_name}' is already in the group" }
	7	+ end

config/initializers/assets.rb created 644 ¶ +23

@@ -0,0 +1,23
	1	+ # Be sure to restart your server when you modify this file.
	2	+
	3	+ # Version of your assets, change this if you want to expire all your assets.
	4	+ Rails.application.config.assets.version = '1.0'
	5	+
	6	+ # Add additional assets to the asset load path.
	7	+ # Rails.application.config.assets.paths << Emoji.images_path
	8	+ # Add Yarn node_modules folder to the asset load path.
	9	+ Rails.application.config.assets.paths << Rails.root.join('node_modules')
	10	+ Rails.application.config.assets.paths << Rails.root.join('vendor/assets/fonts')
	11	+
	12	+ # Precompile additional assets.
	13	+ # application.js, application.css, and all non-JS/CSS in the app/assets
	14	+ # folder are already added.
	15	+ # Rails.application.config.assets.precompile += %w( admin.js admin.css )
	16	+
	17	+ Rails.application.config.assets.precompile += ['announcement_refresh.js','effects.js','site_update.js']
	18	+ Rails.application.config.assets.precompile += ['local_jquery.js','tablesorter-theme.cafe.css']
	19	+ %w( announcements submissions configurations contests contest_management graders heartbeat
	20	+ login main messages problems report site sites sources tasks groups
	21	+ test user_admin users ).each do \|controller\|
	22	+ Rails.application.config.assets.precompile += ["#{controller}.js", "#{controller}.css"]
	23	+ end

app/controllers/groups_controller.rb ¶ +12 -4

               class GroupsController < ApplicationController
                 before_action :set_group, only: [:show, :edit, :update, :destroy,
                                                  :add_user, :remove_user,
                                                  :add_problem, :remove_problem,
                                                 ]
                 before_action :authenticate, :admin_authorization
                 # GET /groups
                 def index
                   @groups = Group.all
                 end
                 # GET /groups/1
                 def show
                 end
                 # GET /groups/new
                 def new
                   @group = Group.new
                 end
                 # GET /groups/1/edit
                 def edit
                 end
                 # POST /groups
                 def create
                   @group = Group.new(group_params)
                   if @group.save
                     redirect_to @group, notice: 'Group was successfully created.'
                   else
                     render :new
                   end
                 end
                 # PATCH/PUT /groups/1
                 def update
                   if @group.update(group_params)
                     redirect_to @group, notice: 'Group was successfully updated.'
                   else
                     render :edit
                   end
                 end
                 # DELETE /groups/1
                 def destroy
                   @group.destroy
                   redirect_to groups_url, notice: 'Group was successfully destroyed.'
                 end
                 def remove_user
                   user = User.find(params[:user_id])
                   @group.users.delete(user)
-            -     redirect_to group_path(@group), notice: "User #{user.login} was removed from the group #{@group.name}"
+            +     redirect_to group_path(@group), flash: {success: "User #{user.login} was removed from the group #{@group.name}"}
                 end
                 def add_user
                   user = User.find(params[:user_id])
+            +     begin
                     @group.users << user
-            -     redirect_to group_path(@group), notice: "User #{user.login} was add to the group #{@group.name}"
+            +       redirect_to group_path(@group), flash: { success: "User #{user.login} was add to the group #{@group.name}"}
+            +     rescue => e
+            +       redirect_to group_path(@group), alert: e.message
+            +     end
                 end
                 def remove_problem
                   problem = Problem.find(params[:problem_id])
                   @group.problems.delete(problem)
-            -     redirect_to group_path(@group), notice: "Problem #{problem.name} was removed from the group #{@group.name}"
+            +     redirect_to group_path(@group), flash: {success: "Problem #{problem.name} was removed from the group #{@group.name}" }
                 end
                 def add_problem
                   problem = Problem.find(params[:problem_id])
+            +     begin
                     @group.problems << problem
-            -     redirect_to group_path(@group), notice: "Problem #{problem.name} was add to the group #{@group.name}"
+            +       redirect_to group_path(@group), flash: {success: "Problem #{problem.name} was add to the group #{@group.name}" }
+            +     rescue => e
+            +       redirect_to group_path(@group), alert: e.message
+            +     end
                 end
                 private
                   # Use callbacks to share common setup or constraints between actions.
                   def set_group
                     @group = Group.find(params[:id])
                   end
                   # Only allow a trusted parameter "white list" through.
                   def group_params
                     params.require(:group).permit(:name, :description)
                   end
               end

app/controllers/problems_controller.rb ¶ +10

                 in_place_edit_for :problem, :full_score
                 def index
                   @problems = Problem.order(date_added: :desc)
                 end
                 # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
                 verify :method => :post, :only => [ :create, :quick_create,
                                                     :do_manage,
                                                     :do_import,
                                                   ],
                        :redirect_to => { :action => :index }
                 def show
                   @problem = Problem.find(params[:id])
                 end
                 def new
                   @problem = Problem.new
                   @description = nil
                 end
                 def create
                   @problem = Problem.new(problem_params)
                   @description = Description.new(params[:description])
                   if @description.body!=''
                     if !@description.save
                       render :action => new and return
                     end
                   else
                     @description = nil
                   end
                   @problem.description = @description
                   if @problem.save
                     flash[:notice] = 'Problem was successfully created.'
                     redirect_to action: :index
                   else
                     render :action => 'new'
                   end
                 end
                 def quick_create
                   @problem = Problem.new(problem_params)
                   @problem.full_name = @problem.name if @problem.full_name == ''
                   @problem.full_score = 100
                   @problem.available = false
                   @problem.test_allowed = true
                   @problem.output_only = false
                   @problem.date_added = Time.new
                   if @problem.save
                     flash[:notice] = 'Problem was successfully created.'
                     redirect_to action: :index
                   else
                     flash[:notice] = 'Error saving problem'
                   redirect_to action: :index
                   end
                 end
                 def edit
                   @problem = Problem.find(params[:id])
                   @description = @problem.description
                 end
                 def update
                   @problem = Problem.find(params[:id])
                   @description = @problem.description
                   if @description.nil? and params[:description][:body]!=''
                     @description = Description.new(params[:description])
                     if !@description.save
                       flash[:notice] = 'Error saving description'
                       render :action => 'edit' and return
                     end
                     @problem.description = @description
                   elsif @description
                     if !@description.update_attributes(params[:description])
                       flash[:notice] = 'Error saving description'
                       render :action => 'edit' and return
                     end
                   end
                   if params[:file] and params[:file].content_type != 'application/pdf'
                       flash[:notice] = 'Error: Uploaded file is not PDF'
                       render :action => 'edit' and return
                   end
                   if @problem.update_attributes(problem_params)
                     flash[:notice] = 'Problem was successfully updated.'
                     unless params[:file] == nil or params[:file] == ''
                       flash[:notice] = 'Problem was successfully updated and a new PDF file is uploaded.'
                       out_dirname = "#{Problem.download_file_basedir}/#{@problem.id}"
                       if not FileTest.exists? out_dirname
                         Dir.mkdir out_dirname
                       end
                       out_filename = "#{out_dirname}/#{@problem.name}.pdf"
                       if FileTest.exists? out_filename
                         File.delete out_filename
                       end
                       File.open(out_filename,"wb") do |file|
                         file.write(params[:file].read)
                       end
                       @problem.description_filename = "#{@problem.name}.pdf"
                       @problem.save
                     end
                     redirect_to :action => 'show', :id => @problem
                   else
                     render :action => 'edit'
                   end
                 end
                 def destroy
                   p = Problem.find(params[:id]).destroy
                   redirect_to action: :index
                 end
                 def toggle
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(available: !(@problem.available) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def toggle_test
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(test_allowed: !(@problem.test_allowed?) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def toggle_view_testcase
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(view_testcase: !(@problem.view_testcase?) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def turn_all_off
                   Problem.available.all.each do |problem|
                     problem.available = false
                     problem.save
                   end
                   redirect_to action: :index
                 end
                 def turn_all_on
                   Problem.where.not(available: true).each do |problem|
                     problem.available = true
                     problem.save
                   end
                   redirect_to action: :index
                 end
                 def stat
                   @problem = Problem.find(params[:id])
                   unless @problem.available or session[:admin]
                     redirect_to :controller => 'main', :action => 'list'
                     return
                   end
                   @submissions = Submission.includes(:user).where(problem_id: params[:id]).order(:user_id,:id)
                   #stat summary
                   range =65
                   @histogram = { data: Array.new(range,0), summary: {} }
                   user = Hash.new(0)
                   @submissions.find_each do |sub|
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     @histogram[:data][d.to_i] += 1 if d < range
                     user[sub.user_id] = [user[sub.user_id], ((sub.try(:points) || 0) >= @problem.full_score) ? 1 : 0].max
                   end
                   @histogram[:summary][:max] = [@histogram[:data].max,1].max
                   @summary = { attempt: user.count, solve: 0 }
                   user.each_value { |v| @summary[:solve] += 1 if v == 1 }
                 end
                 def manage
                   @problems = Problem.order(date_added: :desc)
                 end
                 def do_manage
                   if params.has_key? 'change_date_added'
                     change_date_added
                   elsif params.has_key? 'add_to_contest'
                     add_to_contest
                   elsif params.has_key? 'enable_problem'
                     set_available(true)
                   elsif params.has_key? 'disable_problem'
                     set_available(false)
                   elsif params.has_key? 'add_group'
                     group = Group.find(params[:group_id])
+            +       ok = []
+            +       failed = []
                     get_problems_from_params.each do |p|
+            +         begin
                         group.problems << p
+            +           ok << p.full_name
+            +         rescue => e
+            +           failed << p.full_name
                       end
                     end
+            +       flash[:success] = "The following problems are added to the group #{group.name}: " + ok.join(', ') if ok.count > 0
+            +       flash[:alert] = "The following problems are already in the group #{group.name}: " + failed.join(', ') if failed.count > 0
+            +     end
+            +
                   redirect_to :action => 'manage'
                 end
                 def import
                   @allow_test_pair_import = allow_test_pair_import?
                 end
                 def do_import
                   old_problem = Problem.find_by_name(params[:name])
                   if !allow_test_pair_import? and params.has_key? :import_to_db
                     params.delete :import_to_db
                   end
                   @problem, import_log = Problem.create_from_import_form_params(params,
                                                                                 old_problem)
                   if !@problem.errors.empty?
                     render :action => 'import' and return
                   end
                   if old_problem!=nil
                     flash[:notice] = "The test data has been replaced for problem #{@problem.name}"
                   end
                   @log = import_log
                 end
                 def remove_contest
                   problem = Problem.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if problem!=nil and contest!=nil
                     problem.contests.delete(contest)
                   end
                   redirect_to :action => 'manage'
                 end
                 ##################################
                 protected
                 def allow_test_pair_import?
                   if defined? ALLOW_TEST_PAIR_IMPORT
                     return ALLOW_TEST_PAIR_IMPORT
                   else
                     return false
                   end
                 end
                 def change_date_added
                   problems = get_problems_from_params
                   year = params[:date_added][:year].to_i
                   month = params[:date_added][:month].to_i
                   day = params[:date_added][:day].to_i
                   date = Date.new(year,month,day)
                   problems.each do |p|
                     p.date_added = date
                     p.save
                   end
                 end
                 def add_to_contest
                   problems = get_problems_from_params
                   contest = Contest.find(params[:contest][:id])
                   if contest!=nil and contest.enabled
                     problems.each do |p|
                       p.contests << contest
                     end
                   end
                 end
                 def set_available(avail)
                   problems = get_problems_from_params
                   problems.each do |p|
                     p.available = avail
                     p.save
                   end
                 end
                 def get_problems_from_params
                   problems = []
                   params.keys.each do |k|
                     if k.index('prob-')==0
                       name, id, order = k.split('-')
                       problems << Problem.find(id)
                     end
                   end
                   problems
                 end
                 def get_problems_stat
                 end
                 private
                   def problem_params
                     params.require(:problem).permit(:name, :full_name, :full_score, :date_added, :available, :test_allowed,:output_only, :url, :description)
                   end
               end

app/controllers/user_admin_controller.rb ¶ +12 -1

                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     " were successfully reassigned to #{contest.title}."
                   redirect_to :action => 'contests', :id =>contest.id
                 end
                 def add_to_contest
                   user = User.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if user and contest
                     user.contests << contest
                   end
                   redirect_to :action => 'index'
                 end
                 def remove_from_contest
                   user = User.find(params[:id])
                   contest = Contest.find(params[:contest_id])
                   if user and contest
                     user.contests.delete(contest)
                   end
                   redirect_to :action => 'index'
                 end
                 def contest_management
                 end
                 def manage_contest
                   contest = Contest.find(params[:contest][:id])
                   if !contest
                     flash[:notice] = 'You did not choose the contest.'
                     redirect_to :action => 'contest_management' and return
                   end
                   operation = params[:operation]
                   if not ['add','remove','assign'].include? operation
                     flash[:notice] = 'You did not choose the operation to perform.'
                     redirect_to :action => 'contest_management' and return
                   end
                   lines = params[:login_list]
                   if !lines or lines.blank?
                     flash[:notice] = 'You entered an empty list.'
                     redirect_to :action => 'contest_management' and return
                   end
                   note = []
                   users = []
                   lines.split("\n").each do |line|
                     user = User.find_by_login(line.chomp)
                     if user
                       if operation=='add'
                         if ! user.contests.include? contest
                           user.contests << contest
                         end
                       elsif operation=='remove'
                         user.contests.delete(contest)
                       else
                         user.contests = [contest]
                       end
                       if params[:reset_timer]
                         user.contest_stat.forced_logout = true
                         user.contest_stat.reset_timer_and_save
                       end
                       if params[:notification_emails]
                         send_contest_update_notification_email(user, contest)
                       end
                       note << user.login
                       users << user
                     end
                   end
                   if params[:reset_timer]
                     logout_users(users)
                   end
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     ' were successfully modified.  '
                   redirect_to :action => 'contest_management'
                 end
                 # admin management
                 def admin
                   @admins = User.all.find_all {|user| user.admin? }
                 end
                 def grant_admin
                   login = params[:login]
                   user = User.find_by_login(login)
                   if user!=nil
                     admin_role = Role.find_by_name('admin')
                     user.roles << admin_role
                   else
                     flash[:notice] = 'Unknown user'
                   end
                   flash[:notice] = 'User added as admins'
                   redirect_to :action => 'admin'
                 end
                 def revoke_admin
                   user = User.find(params[:id])
                   if user==nil
                     flash[:notice] = 'Unknown user'
                     redirect_to :action => 'admin' and return
                   elsif user.login == 'root'
                     flash[:notice] = 'You cannot revoke admisnistrator permission from root.'
                     redirect_to :action => 'admin' and return
                   end
                   admin_role = Role.find_by_name('admin')
                   user.roles.delete(admin_role)
                   flash[:notice] = 'User permission revoked'
                   redirect_to :action => 'admin'
                 end
                 # mass mailing
                 def mass_mailing
                 end
                 def bulk_mail
                   lines = params[:login_list]
                   if !lines or lines.blank?
                     flash[:notice] = 'You entered an empty list.'
                     redirect_to :action => 'mass_mailing' and return
                   end
                   mail_subject = params[:subject]
                   if !mail_subject or mail_subject.blank?
                     flash[:notice] = 'You entered an empty mail subject.'
                     redirect_to :action => 'mass_mailing' and return
                   end
                   mail_body = params[:email_body]
                   if !mail_body or mail_body.blank?
                     flash[:notice] = 'You entered an empty mail body.'
                     redirect_to :action => 'mass_mailing' and return
                   end
                   note = []
                   users = []
                   lines.split("\n").each do |line|
                     user = User.find_by_login(line.chomp)
                     if user
                       send_mail(user.email, mail_subject, mail_body)
                       note << user.login
                     end
                   end
                   flash[:notice] = 'User(s) ' + note.join(', ') +
                     ' were successfully modified.  '
                   redirect_to :action => 'mass_mailing'
                 end
                 #bulk manage
                 def bulk_manage
                   begin
                     @users = User.where('(login REGEXP ?) OR (remark REGEXP ?)',params[:regex],params[:regex]) if params[:regex]
                     @users.count if @users #i don't know why I have to call count, but if I won't exception is not raised
                   rescue Exception
                     flash[:error] = 'Regular Expression is malformed'
                     @users = nil
                   end
                   if params[:commit]
                     @action = {}
                     @action[:set_enable] = params[:enabled]
                     @action[:enabled] = params[:enable] == "1"
                     @action[:gen_password] = params[:gen_password]
                     @action[:add_group] = params[:add_group]
                     @action[:group_name] = params[:group_name]
                   end
                   if params[:commit] == "Perform"
                     if @action[:set_enable]
                       @users.update_all(enabled: @action[:enabled])
                     end
                     if @action[:gen_password]
                       @users.each do |u|
                         password = random_password
                         u.password = password
                         u.password_confirmation = password
                         u.save
                       end
                     end
                     if @action[:add_group] and @action[:group_name]
                       @group = Group.find(@action[:group_name])
-            -         @users.each { |user|  @group.users << user }
+            +         ok = []
+            +         failed = []
+            +         @users.each do |user|
+            +           begin
+            +             @group.users << user
+            +             ok << user.login
+            +           rescue => e
+            +             failed << user.login
+            +           end
+            +         end
+            +         flash[:success] = "The following users are added to the 'group #{@group.name}': " + ok.join(', ') if ok.count > 0
+            +         flash[:alert] = "The following users are already in the 'group #{@group.name}': " + failed.join(', ') if failed.count > 0
                     end
                   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
                 def logout_users(users)
                   users.each do |user|
                     contest_stat = user.contest_stat(true)
                     if contest_stat and !contest_stat.forced_logout
                       contest_stat.forced_logout = true
                       contest_stat.save
                     end
                   end
                 end
                 def send_contest_update_notification_email(user, contest)
                   contest_title_name = GraderConfiguration['contest.name']
                   contest_name = contest.name
                   mail_subject = t('contest.notification.email_subject', {
                                      :contest_title_name => contest_title_name,
                                      :contest_name => contest_name })
                   mail_body = t('contest.notification.email_body', {
                                   :full_name => user.full_name,
                                   :contest_title_name => contest_title_name,
                                   :contest_name => contest.name,
                                 })
                   logger.info mail_body
                   send_mail(user.email, mail_subject, mail_body)
                 end
                 def find_contest_and_user_from_contest_id(id)
                   if id!='none'
                     @contest = Contest.find(id)
                   else
                     @contest = nil
                   end
                   if @contest
                     @users = @contest.users
                   else
                     @users = User.find_users_with_no_contest
                   end
                   return [@contest, @users]
                 end
                 def gen_csv_from_scorearray(scorearray,problem)
                   CSV.generate do |csv|
                     #add header
                     header = ['User','Name', 'Activated?', 'Logged in', 'Contest']
                     problem.each { |p| header << p.name }
                     header += ['Total','Passed']
                     csv << header
                     #add data
                     scorearray.each do |sc|
                       total = num_passed = 0
                       row = Array.new
                       sc.each_index do |i|
                         if i == 0
                           row << sc[i].login
                           row << sc[i].full_name
                           row << sc[i].activated
                           row << (sc[i].try(:contest_stat).try(:started_at).nil? ? 'no' : 'yes')
                           row << sc[i].contests.collect {|c| c.name}.join(', ')
                         else
                           row << sc[i][0]
                           total += sc[i][0]
                           num_passed += 1 if sc[i][1]
                         end
                       end
                       row << total
                       row << num_passed
                       csv << row
                     end
                   end
                 end
                 private
                   def user_params
                     params.require(:user).permit(:login,:password,:password_confirmation,:email, :alias, :full_name,:remark)
                   end
               end

app/helpers/application_helper.rb ¶ +1 -1

                     left_menu << add_menu("#{I18n.t 'menu.tasks'}", 'tasks', 'list')
                     left_menu << add_menu("#{I18n.t 'menu.submissions'}", 'main', 'submission')
                     left_menu << add_menu("#{I18n.t 'menu.test'}", 'test', 'index')
                   end
                   if GraderConfiguration['right.user_hall_of_fame']
                     left_menu << add_menu("#{I18n.t 'menu.hall_of_fame'}", 'report', 'problem_hof')
                   end
                   right_menu << add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-question-sign')}".html_safe, 'main', 'help')
                   right_menu << add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-comment')}".html_safe, 'messages', 'list', {title: I18n.t('menu.messages'), data: {toggle: 'tooltip'}})
                   if GraderConfiguration['system.user_setting_enabled']
                     right_menu << add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-cog')}".html_safe, 'users', 'index', {title: I18n.t('menu.settings'), data: {toggle: 'tooltip'}})
                   end
                   right_menu << add_menu("#{content_tag(:span,'',class: 'glyphicon glyphicon-log-out')} #{user.full_name}".html_safe, 'main', 'login', {title: I18n.t('menu.log_out'), data: {toggle: 'tooltip'}})
                   result = content_tag(:ul,left_menu.html_safe,class: 'nav navbar-nav') + content_tag(:ul,right_menu.html_safe,class: 'nav navbar-nav navbar-right')
                 end
                 def add_menu(title, controller, action, html_option = {})
                   link_option = {controller: controller, action: action}
                   html_option[:class] = (html_option[:class] || '') + " active" if current_page?(link_option)
                   content_tag(:li, link_to(title,link_option),html_option)
                 end
                 def user_header
                   menu_items = ''
                   user = User.find(session[:user_id])
                   if (user!=nil) and (session[:admin])
                     # admin menu
                     menu_items << "<b>Administrative task:</b> "
                     append_to menu_items, '[Announcements]', 'announcements', 'index'
                     append_to menu_items, '[Msg console]', 'messages', 'console'
                     append_to menu_items, '[Problems]', 'problems', 'index'
                     append_to menu_items, '[Users]', 'user_admin', 'index'
                     append_to menu_items, '[Results]', 'user_admin', 'user_stat'
                     append_to menu_items, '[Report]', 'report', 'multiple_login'
                     append_to menu_items, '[Graders]', 'graders', 'list'
                     append_to menu_items, '[Contests]', 'contest_management', 'index'
                     append_to menu_items, '[Sites]', 'sites', 'index'
                     append_to menu_items, '[System config]', 'configurations', 'index'
                     menu_items << "<br/>"
                   end
                   # main page
                   append_to menu_items, "[#{I18n.t 'menu.main'}]", 'main', 'list'
                   append_to menu_items, "[#{I18n.t 'menu.messages'}]", 'messages', 'list'
                   if (user!=nil) and (GraderConfiguration.show_tasks_to?(user))
                     append_to menu_items, "[#{I18n.t 'menu.tasks'}]", 'tasks', 'list'
                     append_to menu_items, "[#{I18n.t 'menu.submissions'}]", 'main', 'submission'
                     append_to menu_items, "[#{I18n.t 'menu.test'}]", 'test', 'index'
                   end
                   if GraderConfiguration['right.user_hall_of_fame']
                     append_to menu_items, "[#{I18n.t 'menu.hall_of_fame'}]", 'report', 'problem_hof'
                   end
                   append_to menu_items, "[#{I18n.t 'menu.help'}]", 'main', 'help'
                   if GraderConfiguration['system.user_setting_enabled']
                     append_to menu_items, "[#{I18n.t 'menu.settings'}]", 'users', 'index'
                   end
                   append_to menu_items, "[#{I18n.t 'menu.log_out'}]", 'main', 'login'
                   menu_items.html_safe
                 end
                 def append_to(option,label, controller, action)
                   option << ' ' if option!=''
                   option << link_to_unless_current(label,
                                                    :controller => controller,
                                                    :action => action)
                 end
                 def format_short_time(time)
                   now = Time.now.gmtime
                   st = ''
                   if (time.yday != now.yday) or
               	(time.year != now.year)
                     st = time.strftime("%x ")
                   end
                   st + time.strftime("%X")
                 end
                 def format_short_duration(duration)
                   return '' if duration==nil
                   d = duration.to_f
                   return Time.at(d).gmtime.strftime("%X")
                 end
                 def read_textfile(fname,max_size=2048)
                   begin
                     File.open(fname).read(max_size)
                   rescue
                     nil
                   end
                 end
                 def toggle_button(on,toggle_url,id, option={})
                   btn_size = option[:size] || 'btn-xs'
                   link_to (on ? "Yes" : "No"), toggle_url,
                     {class: "btn btn-block #{btn_size} btn-#{on ? 'success' : 'default'} ajax-toggle",
                       id: id,
                       data: {remote: true, method: 'get'}}
                 end
                 def get_ace_mode(language)
                   # return ace mode string from Language
                   case language.pretty_name
                     when 'Pascal'
                       'ace/mode/pascal'
                     when 'C++','C'
                       'ace/mode/c_cpp'
                     when 'Ruby'
                       'ace/mode/ruby'
                     when 'Python'
                       'ace/mode/python'
                     when 'Java'
                       'ace/mode/java'
                     else
                       'ace/mode/c_cpp'
                   end
                 end
                 def user_title_bar(user)
                   header = ''
                   time_left = ''
                   #
                   # if the contest is over
                   if GraderConfiguration.time_limit_mode?
                     if user.contest_finished?
                       header = <<CONTEST_OVER
               <tr><td colspan="2" align="center">
               <span class="contest-over-msg">THE CONTEST IS OVER</span>
               </td></tr>
               CONTEST_OVER
                     end
                     if !user.contest_started?
                       time_left = "&nbsp;&nbsp;" + (t 'title_bar.contest_not_started')
                     else
                       time_left = "&nbsp;&nbsp;" + (t 'title_bar.remaining_time') +
                         " #{format_short_duration(user.contest_time_left)}"
                     end
                   end
                   #
                   # if the contest is in the anaysis mode
                   if GraderConfiguration.analysis_mode?
                     header = <<ANALYSISMODE
               <tr><td colspan="2" align="center">
               <span class="contest-over-msg">ANALYSIS MODE</span>
               </td></tr>
               ANALYSISMODE
                   end
                   contest_name = GraderConfiguration['contest.name']
                   #
                   # build real title bar
                   result = <<TITLEBAR
               <div class="title">
               <table>
               #{header}
               <tr>
               <td class="left-col">
               #{user.full_name}<br/>
               #{t 'title_bar.current_time'} #{format_short_time(Time.zone.now)}
               #{time_left}
               <br/>
               </td>
               <td class="right-col">#{contest_name}</td>
               </tr>
               </table>
               </div>
               TITLEBAR
                   result.html_safe
                 end
                 def markdown(text)
                   markdown = RDiscount.new(text)
                   markdown.to_html.html_safe
                 end
                 BOOTSTRAP_FLASH_MSG = {
                   success: 'alert-success',
                   error: 'alert-danger',
-            -     alert: 'alert-block',
+            +     alert: 'alert-danger',
                   notice: 'alert-info'
                 }
                 def bootstrap_class_for(flash_type)
                   BOOTSTRAP_FLASH_MSG.fetch(flash_type.to_sym, flash_type.to_s)
                 end
                 def flash_messages
                   flash.each do |msg_type, message|
                     concat(content_tag(:div, message, class: "alert #{bootstrap_class_for(msg_type)} fade in") do
                             concat content_tag(:button, 'x', class: "close", data: { dismiss: 'alert' })
                             concat message
                           end)
                   end
                   nil
                 end
               end

app/models/group.rb ¶ +10 -2

@@ -1,5 +1,13
1	class Group < ActiveRecord::Base	1	class Group < ActiveRecord::Base
2	- has_and_belongs_to_many :problems	2	+ has_many :groups_problems, class_name: GroupProblem
3	- has_and_belongs_to_many :users	3	+ has_many :problems, :through => :groups_problems
		4	+
		5	+ has_many :groups_users, class_name: GroupUser
		6	+ has_many :users, :through => :groups_users
		7	+
		8	+ #has_and_belongs_to_many :problems
		9	+ #has_and_belongs_to_many :users
		10	+
		11	+
4	end	12	end
5		13

app/models/problem.rb ¶ +5 -1

               class Problem < ActiveRecord::Base
                 belongs_to :description
                 has_and_belongs_to_many :contests, :uniq => true
-            -   has_and_belongs_to_many :groups
+            +   #has_and_belongs_to_many :groups
+            +   has_many :groups_problems, class_name: GroupProblem
+            +   has_many :groups, :through => :groups_problems
+            +
                 has_many :test_pairs, :dependent => :delete_all
                 has_many :testcases, :dependent => :destroy
                 validates_presence_of :name
                 validates_format_of :name, :with => /\A\w+\z/
                 validates_presence_of :full_name
                 scope :available, -> { where(available: true) }
                 DEFAULT_TIME_LIMIT = 1
                 DEFAULT_MEMORY_LIMIT = 32
                 def self.available_problems
                   available.order(date_added: :desc).order(:name)
                   #Problem.available.all(:order => "date_added DESC, name ASC")
                 end
                 def self.create_from_import_form_params(params, old_problem=nil)
                   org_problem = old_problem || Problem.new
                   import_params, problem = Problem.extract_params_and_check(params,
                                                                             org_problem)
                   if !problem.errors.empty?
                     return problem, 'Error importing'
                   end
                   problem.full_score = 100
                   problem.date_added = Time.new
                   problem.test_allowed = true
                   problem.output_only = false
                   problem.available = false
                   if not problem.save
                     return problem, 'Error importing'
                   end
                   import_to_db = params.has_key? :import_to_db
                   importer = TestdataImporter.new(problem)
                   if not importer.import_from_file(import_params[:file],
                                                    import_params[:time_limit],
                                                    import_params[:memory_limit],
                                                    import_params[:checker_name],
                                                    import_to_db)
                     problem.errors.add(:base,'Import error.')
                   end
                   return problem, importer.log_msg
                 end
                 def self.download_file_basedir
                   return "#{Rails.root}/data/tasks"
                 end
                 def get_submission_stat
                   result = Hash.new
                   #total number of submission
                   result[:total_sub] = Submission.where(problem_id: self.id).count
                   result[:attempted_user] = Submission.where(problem_id: self.id).group(:user_id)
                   result[:pass] = Submission.where(problem_id: self.id).where("points >= ?",self.full_score).count
                   return result
                 end
                 def long_name
                   "[#{name}] #{full_name}"
                 end
                 protected
                 def self.to_i_or_default(st, default)
                   if st!=''
                     result = st.to_i
                   end
                   result ||= default
                 end
                 def self.to_f_or_default(st, default)
                   if st!=''
                     result = st.to_f
                   end
                   result ||= default
                 end
                 def self.extract_params_and_check(params, problem)
                   time_limit = Problem.to_f_or_default(params[:time_limit],
                                                        DEFAULT_TIME_LIMIT)
                   memory_limit = Problem.to_i_or_default(params[:memory_limit],
                                                          DEFAULT_MEMORY_LIMIT)
                   if time_limit<=0 or time_limit >60
                     problem.errors.add(:base,'Time limit out of range.')
                   end
                   if memory_limit==0 and params[:memory_limit]!='0'
                     problem.errors.add(:base,'Memory limit format errors.')
                   elsif memory_limit<=0 or memory_limit >512
                     problem.errors.add(:base,'Memory limit out of range.')
                   end
                   if params[:file]==nil or params[:file]==''
                     problem.errors.add(:base,'No testdata file.')
                   end
                   checker_name = 'text'
                   if ['text','float'].include? params[:checker]
                     checker_name = params[:checker]
                   end
                   file = params[:file]
                   if !problem.errors.empty?
                     return nil, problem
                   end
                   problem.name = params[:name]
                   if params[:full_name]!=''
                     problem.full_name = params[:full_name]
                   else
                     problem.full_name = params[:name]
                   end
                   return [{
                             :time_limit => time_limit,
                             :memory_limit => memory_limit,
                             :file => file,
                             :checker_name => checker_name
                           },
                           problem]
                 end
               end

app/models/user.rb ¶ +4 -1

               require 'digest/sha1'
               require 'net/pop'
               require 'net/https'
               require 'net/http'
               require 'json'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
-            -   has_and_belongs_to_many :groups
+            +   #has_and_belongs_to_many :groups
+            +   has_many :groups_users, class_name: GroupUser
+            +   has_many :groups, :through => :groups_users
                 has_many :test_requests, -> {order(submitted_at: DESC)}
                 has_many :messages, -> { order(created_at: DESC) },
                          :class_name => "Message",
                          :foreign_key => "sender_id"
                 has_many :replied_messages, -> { order(created_at: DESC) },
                          :class_name => "Message",
                          :foreign_key => "receiver_id"
                 has_one :contest_stat, :class_name => "UserContestStat", :dependent => :destroy
                 belongs_to :site
                 belongs_to :country
                 has_and_belongs_to_many :contests, -> { order(:name); uniq}
                 scope :activated_users, -> {where activated: true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /\A[\_A-Za-z0-9]+\z/
                 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
                 before_save :assign_default_contest
                 # this is for will_paginate
                 cattr_reader :per_page
                 @@per_page = 50
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   if user
                     return user if user.authenticated?(password)
                     if user.authenticated_by_cucas?(password) or user.authenticated_by_pop3?(password)
                       user.password = password
                       user.save
                       return user
                     end
                   end
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def authenticated_by_pop3?(password)
                   Net::POP3.enable_ssl
                   pop = Net::POP3.new('pops.it.chula.ac.th')
                   authen = true
                   begin
                     pop.start(login, password)
                     pop.finish
                     return true
                   rescue
                     return false
                   end
                 end
                 def authenticated_by_cucas?(password)
                   url = URI.parse('https://www.cas.chula.ac.th/cas/api/?q=studentAuthenticate')
                   appid = '41508763e340d5858c00f8c1a0f5a2bb'
                   appsecret ='d9cbb5863091dbe186fded85722a1e31'
                   post_args = {
                     'appid' => appid,
                     'appsecret' => appsecret,
                     'username' => login,
                     'password' => password
                   }
                   #simple call
                   begin
                     http = Net::HTTP.new('www.cas.chula.ac.th', 443)
                     http.use_ssl = true
                     http.verify_mode = OpenSSL::SSL::VERIFY_NONE
                     result = [ ]
                     http.start do |http|
                       req = Net::HTTP::Post.new('/cas/api/?q=studentAuthenticate')
                       param = "appid=#{appid}&appsecret=#{appsecret}&username=#{login}&password=#{password}"
                       resp = http.request(req,param)
                       result = JSON.parse resp.body
                     end
                     return true if result["type"] == "beanStudent"
                   rescue => e
                     return false
                   end
                   return false
                 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.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

app/views/problems/index.html.haml ¶ +4 -4

               - content_for :head do
                 = stylesheet_link_tag 'problems'
-            - %h1 Listing problems
+            + %h1 Problems
               %p
-            -   = link_to 'New problem', new_problem_path, class: 'btn btn-default btn-sm'
+            +   = link_to 'Import problems', {:action => 'import'}, class: 'btn btn-success btn-sm'
-            -   = link_to 'Manage problems', { action: 'manage'}, class: 'btn btn-default btn-sm'
+            +   = link_to 'New problem', new_problem_path, class: 'btn btn-success btn-sm'
-            -   = link_to 'Import problems', {:action => 'import'}, class: 'btn btn-default btn-sm'
+            +   = link_to 'Bulk Manage', { action: 'manage'}, class: 'btn btn-info btn-sm'
                 = link_to 'Turn off all problems', {:action => 'turn_all_off'}, class: 'btn btn-default btn-sm'
                 = link_to 'Turn on all problems', {:action => 'turn_all_on'}, class: 'btn btn-default btn-sm'
               .submitbox
                 = form_tag :action => 'quick_create' do
                   %b Quick New:
                   %label{:for => "problem_name"} Name
                   = text_field 'problem', 'name'
                   |
                   %label{:for => "problem_full_name"} Full name
                   = text_field 'problem', 'full_name'
                   = submit_tag "Create"
               %table.table.table-condense.table-hover
                 %thead
                   %th Name
                   %th Full name
                   %th.text-right Full score
                   %th Date added
                   %th.text-center
                     Avail?
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Let user submits to this problem?' } [?]
                   %th.text-center
                     View Data?
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Let user view the testcase of this problem?' } [?]
                   %th.text-center
                     Test?
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Let user uses test interface on this problem?' } [?]
                   - if GraderConfiguration.multicontests?
                     %th Contests
                 - for problem in @problems
                   %tr{:class => "#{(problem.available) ? "success" : "danger"}", :id => "prob-#{problem.id}", :name => "prob-#{problem.id}"}
                     - @problem=problem
                     %td= problem.name #in_place_editor_field :problem, :name, {}, :rows=>1
                     %td= problem.full_name #in_place_editor_field :problem, :full_name, {}, :rows=>1
                     %td.text-right= problem.full_score #in_place_editor_field :problem, :full_score, {}, :rows=>1
                     %td= problem.date_added
                     %td= toggle_button(@problem.available?, toggle_problem_path(@problem), "problem-avail-#{@problem.id}")
                     %td= toggle_button(@problem.view_testcase?, toggle_view_testcase_problem_path(@problem), "problem-view-testcase-#{@problem.id}")
                     %td= toggle_button(@problem.test_allowed?, toggle_test_problem_path(@problem), "problem-test-#{@problem.id}")
                     - if GraderConfiguration.multicontests?
                       %td
                         = problem.contests.collect { |c| c.name }.join(', ')
                     %td= link_to 'Stat', {:action => 'stat', :id => problem.id}, class: 'btn btn-info btn-xs btn-block'
                     %td= link_to 'Show', {:action => 'show', :id => problem}, class: 'btn btn-info btn-xs btn-block'
                     %td= link_to 'Edit', {:action => 'edit', :id => problem}, class: 'btn btn-info btn-xs btn-block'
                     %td= link_to 'Destroy', { :action => 'destroy', :id => problem }, :confirm => 'Are you sure?', :method => :delete, class: 'btn btn-danger btn-xs btn-block'
               %br/
               = link_to '[New problem]', :action => 'new'

app/views/problems/manage.html.haml ¶ +11 -7

               - content_for :head do
                 = stylesheet_link_tag 'problems'
                 = javascript_include_tag 'local_jquery'
               :javascript
                 $(document).ready( function() {
                   function shiftclick(start,stop,value) {
                     $('tr input').each( function(id,input) {
                       var $input=$(input);
                       var iid=parseInt($input.attr('id').split('-')[2]);
                       if(iid>=start&&iid<=stop){
                       $input.prop('checked',value)
                       }
                     });
                   }
                   $('tr input').click( function(e)  {
                     if (e.shiftKey) {
                       stop = parseInt($(this).attr('id').split('-')[2]);
                       var orig_stop = stop
                       if (typeof start !== 'undefined') {
                         if (start > stop) {
                           var tmp = start;
                           start = stop;
                           stop = tmp;
                         }
                         shiftclick(start,stop,$(this).is(':checked') )
                       }
                       start = orig_stop
                     } else {
                       start = parseInt($(this).attr('id').split('-')[2]);
                     }
                   });
                 });
               %h1 Manage problems
-            - %p= link_to '[Back to problem list]', :action => 'list'
+            + %p= link_to '[Back to problem list]', problems_path
               = form_tag :action=>'do_manage' do
-            -   .submitbox.panel
+            +   .panel.panel-primary
+            +     .panel-heading
+            +       Action
+            +     .panel-body
+            +       .submit-box
                       What do you want to do to the selected problem?
                       %br/
                       (You can shift-click to select a range of problems)
                       %ul
                         %li
                           Change date added to
                           = select_date Date.current, :prefix => 'date_added'
                           &nbsp;&nbsp;&nbsp;
-            -         = submit_tag 'Change', :name => 'change_date_added'
+            +             = submit_tag 'Change', :name => 'change_date_added', class: 'btn btn-default'
                         %li
                           Set available to
-            -         = submit_tag 'True', :name => 'enable_problem'
+            +             = submit_tag 'True', :name => 'enable_problem', class: 'btn btn-default'
-            -         = submit_tag 'False', :name => 'disable_problem'
+            +             = submit_tag 'False', :name => 'disable_problem', class: 'btn btn-default'
                         - if GraderConfiguration.multicontests?
                           %li
                             Add to
                             = select("contest","id",Contest.all.collect {|c| [c.title, c.id]})
-            -           = submit_tag 'Add', :name => 'add_to_contest'
+            +               = submit_tag 'Add', :name => 'add_to_contest', class: 'btn btn-default'
                         %li
                           Add problems to group
                           = select_tag "group_id", options_from_collection_for_select( Group.all, 'id','name',params[:group_name]), id: 'group_name',class: 'select2'
-            -         = submit_tag 'Add', name: 'add_group'
+            +             = submit_tag 'Add', name: 'add_group', class: 'btn btn-default'
                 %table.table.table-hover
                   %tr{style: "text-align: left;"}
                     %th= check_box_tag 'select_all'
                     %th Name
                     %th Full name
                     %th Available
                     %th Date added
                     - if GraderConfiguration.multicontests?
                       %th Contests
                   - num = 0
                   - for problem in @problems
                     - num += 1
                     %tr{:id => "row-prob-#{problem.id}", :name=> "prob-#{problem.id}"}
                       %td= check_box_tag "prob-#{problem.id}-#{num}"
                       %td= problem.name
                       %td= problem.full_name
                       %td= problem.available
                       %td= problem.date_added
                       - if GraderConfiguration.multicontests?
                         %td
                           - problem.contests.each do |contest|
                             = "(#{contest.name} [#{link_to 'x', :action => 'remove_contest', :id => problem.id, :contest_id => contest.id }])"

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

r689:124074894d4b - Wed, 13 Sep 2017 10:45:07 - 16 files changed: 106 inserted, 21 deleted

Sign in to your account

Commit r689:124074894d4b public

Author

r689:124074894d4b - Wed, 13 Sep 2017 10:45:07 - 16 files changed: 106 inserted, 21 deleted

Commit `r689:124074894d4b` public