cafe-grader-web Commit - r121:00c0c912cae9

cafe-grader-web

Commit `r121:00c0c912cae9` public

parent | child

Description:

[web] fix time.new, time.now to use gmtime git-svn-id: http://theory.cpe.ku.ac.th/grader/web/trunk@249 6386c4cd-e34a-4fa8-8920-d93eb39b512e

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r121:00c0c912cae9 - Wed, 07 May 2008 01:06:30 - 3 files changed: 3 inserted, 3 deleted

app/controllers/main_controller.rb ¶ +1 -1

               class MainController < ApplicationController
                 before_filter :authenticate, :except => [:index, :login]
               #
               #  COMMENT OUT: filter in each action instead
               #
               #  before_filter :verify_time_limit, :only => [:submit]
                 verify :method => :post, :only => [:submit],
                        :redirect_to => { :action => :index }
                 def index
                   redirect_to :action => 'login'
                 end
                 def login
                   saved_notice = flash[:notice]
                   reset_session
                   flash[:notice] = saved_notice
                   render :action => 'login', :layout => 'empty'
                 end
                 def list
                   prepare_list_information
                 end
                 def help
                   @user = User.find(session[:user_id])
                 end
                 def submit
                   user = User.find(session[:user_id])
                   @submission = Submission.new(params[:submission])
                   @submission.user = user
                   @submission.language_id = 0
                   if params['file']!=''
                     @submission.source = params['file'].read
                     @submission.source_filename = params['file'].original_filename
                   end
-            -     @submission.submitted_at = Time.new
+            +     @submission.submitted_at = Time.new.gmtime
                   if user.site!=nil and user.site.finished?
                     @submission.errors.add_to_base "The contest is over."
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   if @submission.valid?
                     if @submission.save == false
               	flash[:notice] = 'Error saving your submission'
                     elsif Task.create(:submission_id => @submission.id,
                                       :status => Task::STATUS_INQUEUE) == false
               	flash[:notice] = 'Error adding your submission to task queue'
                     end
                   else
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   redirect_to :action => 'list'
                 end
                 def source
                   submission = Submission.find(params[:id])
                   if submission.user_id == session[:user_id]
                     if submission.problem.output_only
                       fname = submission.source_filename
                     else
                       fname = submission.problem.name + '.' + submission.language.ext
                     end
                     send_data(submission.source,
               		{:filename => fname,
                                 :type => 'text/plain'})
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def compiler_msg
                   @submission = Submission.find(params[:id])
                   if @submission.user_id == session[:user_id]
                     render :action => 'compiler_msg', :layout => 'empty'
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def submission
                   @user = User.find(session[:user_id])
                   @problems = Problem.find_available_problems
                   if params[:id]==nil
                     @problem = nil
                     @submissions = nil
                   else
                     @problem = Problem.find_by_name(params[:id])
                     @submissions = Submission.find_all_by_user_problem(@user.id, @problem.id)
                   end
                 end
                 def error
                   @user = User.find(session[:user_id])
                 end
                 protected
                 def prepare_list_information
                   @problems = Problem.find_available_problems
                   @prob_submissions = Array.new
                   @user = User.find(session[:user_id])
                   @problems.each do |p|
                     sub = Submission.find_last_by_user_and_problem(@user.id,p.id)
                     if sub!=nil
                       @prob_submissions << { :count => sub.number, :submission => sub }
                     else
                       @prob_submissions << { :count => 0, :submission => nil }
                     end
                   end
                   @announcements = Announcement.find(:all,
                                                      :conditions => "published = 1",
                                                      :order => "created_at DESC")
                 end
               end

app/models/site.rb ¶ +1 -1

               class Site < ActiveRecord::Base
                 belongs_to :country
                 has_many :users
                 def clear_start_time_if_not_started
                   if !self.started
                     self.start_time = nil
                   end
                 end
                 def finished?
                   if !self.started
                     return false
                   end
                   contest_time = Configuration['contest.time_limit']
                   if tmatch = /(\d+):(\d+)/.match(contest_time)
                     h = tmatch[1].to_i
                     m = tmatch[2].to_i
-            -       return Time.now > (self.start_time + h.hour + m.minute)
+            +       return Time.now.gmtime > (self.start_time + h.hour + m.minute)
                   else
                     false
                   end
                 end
               end

app/models/test_request.rb ¶ +1 -1

               #
               # A TestRequest is a composition of submission with user's testdata.
               #
               # Note about TestRequest#problem: Usually, A TestRequest has to be
               #   associated with a problem, so that execution environment can be
               #   determined.  However, to be more flexible, we have to ensure that
               #   it works as well with problem=nil.  In this case, we shall provide
               #   a "default" execution environment for it.  This can be done
               #   seamlessly by using TestRequest#problem_name or
               #   TestRequest#name_of(problem) when retrieving the name of the
               #   problem: #name_of would return problem.name when problem!=nil and
               #   it would return "default" when problem=nil, #problem_name just
               #   call #name_of.
               #
               require 'fileutils'
               class TestRequest < Task
                 set_table_name "test_requests"
                 belongs_to :user
                 belongs_to :problem
                 belongs_to :submission
                 validates_presence_of :submission
                 validate :must_have_valid_problem
                 def problem_name
                   TestRequest.name_of(self.problem)
                 end
                 def language
                   self.submission.language
                 end
                 def self.get_inqueue_and_change_status(status)
                   # since there will be only one grader grading TestRequest
                   # we do not need locking (hopefully)
                   test_request = TestRequest.find(:first,
                                                   :order => "created_at",
                                                   :conditions => {:status=> Task::STATUS_INQUEUE})
                   if test_request!=nil
                     test_request.status = status
                     test_request.save!
                   end
                   test_request
                 end
                 # interfacing with form
                 def self.new_from_form_params(user,params)
                   test_request = TestRequest.new
                   test_request.user = user
                   begin
                     problem = Problem.find(params[:problem_id])
                   rescue ActiveRecord::RecordNotFound
                     problem = nil
                   end
                   test_request.problem = problem
                   if problem!=nil
                     test_request.submission =
                       Submission.find_by_user_problem_number(user.id,
                                                              problem.id,
                                                              params[:submission_number])
                   else
                     test_request.submission = nil
                   end
                   # checks if the user submits any input file
                   if params[:input_file]==nil or params[:input_file]==""
                     test_request.errors.add_to_base("No input submitted.")
                     test_request.input_file_name = nil
                   else
                     test_request.input_file_name = save_input_file(params[:input_file], user, problem)
                     if test_request.input_file_name == nil
                       test_request.errors.add_to_base("No input submitted.")
                     end
                     if params[:additional_file]!=nil and params[:additional_file]!=""
                       save_additional_file(params[:additional_file],
                                            "#{test_request.input_file_name}.files")
                     end
                   end
-            -     test_request.submitted_at = Time.new
+            +     test_request.submitted_at = Time.new.gmtime
                   test_request.status_inqueue
                   test_request
                 end
                 protected
                 def self.name_of(problem)
                   if problem!=nil
                     problem.name
                   else
                     "default"
                   end
                 end
                 def self.random_input_file_name(user,problem)
                   problem_name = TestRequest.name_of(problem)
                   begin
                     tmpname = TEST_REQUEST_INPUT_FILE_DIR + "/#{user.login}/#{problem_name}/#{rand(10000)}"
                   end while File.exists?(tmpname)
                   tmpname
                 end
                 def self.save_input_file(tempfile, user, problem)
                   new_file_name = random_input_file_name(user,problem)
                   dirname = File.dirname(new_file_name)
                   FileUtils.mkdir_p(File.dirname(new_file_name)) if !File.exists?(dirname)
                   # when the user did not submit any file
                   return nil if tempfile==""
                   if tempfile.instance_of?(Tempfile)
                     tempfile.close
                     FileUtils.move(tempfile.path,new_file_name)
                   else
                     File.open(new_file_name, "wb") do |f|
                       f.write(tempfile.read)
                     end
                   end
                   new_file_name
                 end
                 def self.save_additional_file(tempfile,dir)
                   new_file_name = "#{dir}/#{tempfile.original_filename}"
                   dirname = File.dirname(new_file_name)
                   FileUtils.mkdir_p(File.dirname(new_file_name)) if !File.exists?(dirname)
                   # when the user did not submit any file
                   return nil if tempfile==""
                   if tempfile.instance_of?(Tempfile)
                     tempfile.close
                     FileUtils.move(tempfile.path,new_file_name)
                   else
                     File.open(new_file_name, "wb") do |f|
                       f.write(tempfile.read)
                     end
                   end
                   new_file_name
                 end
                 #
                 # validations
                 #
                 def must_have_valid_problem
                   if problem==nil
                     errors.add('problem',"must be specified.")
                   elsif (!problem.available) and (self.new_record?)
                     errors.add('problem',"must be valid.")
                   end
                 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

r121:00c0c912cae9 - Wed, 07 May 2008 01:06:30 - 3 files changed: 3 inserted, 3 deleted

Sign in to your account

Commit r121:00c0c912cae9 public

Author

r121:00c0c912cae9 - Wed, 07 May 2008 01:06:30 - 3 files changed: 3 inserted, 3 deleted

Commit `r121:00c0c912cae9` public