class Courses

Attributes

dir_diplomas[R]
dir_exams[R]
dir_exams_share[R]
print_exa[R]
print_exa_long[R]
print_presence[R]
print_presence_small[R]

Public Class Methods

create_ctype(ctype, date, creator = nil) click to toggle source
# File Entities/Course.rb, line 125
def self.create_ctype(ctype, date, creator = nil)
  #dputs_func
  needs_center = (ConfigBase.has_function?(:course_server) and
      (creator and creator.has_permission?(:center)))
  dputs(4) { "needs_center is #{needs_center.inspect}" }

  # Prepare correct name
  name = if needs_center
           if creator.permissions.index 'center'
             creator.login_name
           else
             Persons.find_by_permissions(:center).login_name
           end + '_'
         else
           ''
         end + "#{ctype.name}_#{date}"

  # Check for double names
  suffix = ''
  counter = 1
  while Courses.match_by_name(name + suffix)
    counter += 1
    suffix = "-#{counter}"
  end
  name += suffix

  course = self.create(:name => name)
  course.data_set_hash(ctype.to_hash.except(:name), true).ctype = ctype

  if needs_center
    dputs(3) { "Got center of #{creator.inspect}" }
    course.center = creator
  end

  if ConfigBase.get_functions.index :accounting_courses
    course.create_account
  end

  course.salary_teacher = ctype.salary_teacher
  course.cost_student = ctype.cost_student

  log_msg :course, "Created new course #{course.inspect}"
  return course
end
from_date_fr(str) click to toggle source
# File Entities/Course.rb, line 170
def self.from_date_fr(str)
  day, month, year = str.split(' ')
  day = day.gsub(/^0/, '')
  if day == '1er'
    day = '1'
  end
  month = %w( janvier février mars avril mai juin juillet août
  septembre octobre novembre décembre ).index(month) + 1
  "#{day.to_s.rjust(2, '0')}.#{month.to_s.rjust(2, '0')}.#{year.to_s.rjust(4, '2000')}"
end
from_diploma(course_name, course_str) click to toggle source
# File Entities/Course.rb, line 181
def self.from_diploma(course_name, course_str)
  dputs(1) { "Importing #{course_name}: #{course_str.gsub(/\n/, '*')}" }
  course = Entities.Courses.match_by_name(course_name) or
      Entities.Courses.create(:name => course_name)

  lines = course_str.split("\n")
  template = lines.shift
  dputs(2) { "Template is: #{template}" }
  dputs(2) { "lines are: #{lines.inspect}" }
  case template
    when /base_gestion/ then
      course.teacher, course.responsible = lines.shift(2).collect { |p|
        Entities.Persons.find_full_name(p)
      }
      if not course.teacher or not course.responsible then
        return nil
      end
      course.teacher, course.responsible = course.teacher.login_name, course.responsible.login_name
      course.duration, course.description = lines.shift(2)
      course.contents = ''
      while lines[0].size > 0
        course.contents += lines.shift
      end
      dputs(2) { "Course contents: #{course.contents}" }
      lines.shift
      course.start, course.end, course.sign =
          lines.shift(3).collect { |d| self.from_date_fr(d) }
      lines.shift if lines[0].size == 0

      course.students = []
      while lines.size > 0
        grade, name = lines.shift.split(' ', 2)
        student = Entities.Persons.find_name_or_create(name)
        course.students_add student
        g = Grades.match_by_course_person(course, student)
        if g then
          g.mean, g.remark = Grades.grade_to_mean(grade), lines.shift
        else
          Grades.create(:course => course, :student => student,
                        :mean => Grades.grade_to_mean(grade), :remark => lines.shift)
        end
      end
      dputs(3) { "#{course.inspect}" }
    else
      import_old(lines)
  end
  course
end

Public Instance Methods

center_course_name(course, user) click to toggle source
# File Entities/Course.rb, line 294
def center_course_name(course, user)
  course =~ /^#{user}_/ ? course : "#{user}_#{course}"
end
icc_course(tr) click to toggle source
# File Entities/Course.rb, line 333
def icc_course(tr)
  course = tr._data.to_sym
  dputs(3) { "Course is #{course.inspect}" }
  course.delete :course_id
  course._name = center_course_name(course._name, tr._user)
  course._responsible = Persons.match_by_login_name(
      "#{tr._user}_#{course._responsible}")
  course._teacher = Persons.match_by_login_name(
      "#{tr._user}_#{course._teacher}")
  course._assistant = Persons.match_by_login_name(
      "#{tr._user}_#{course._assistant}")
  course._students = course._students.collect { |s| "#{tr._user}_#{s}" }
  course._ctype = CourseTypes.match_by_name(course._ctype)
  return "Error: couldn't make course of type #{course._ctype}" unless course._ctype
  course._center = Persons.match_by_login_name(tr._user)
  course._room = Rooms.find_by_name('')
  dputs(3) { "Course is now #{course.inspect}" }
  if c = Courses.match_by_name(course._name)
    dputs(3) { "Updating course #{course._name}" }
    c.data_set_hash(course)
  else
    dputs(3) { "Creating course #{course._name}" }
    Courses.create(course)
  end
  "Updated course #{course._name}"
end
icc_courses(tr) click to toggle source
# File Entities/Course.rb, line 314
def icc_courses(tr)
  c = tr._center
  return "Error: Didn't find center #{c.inspect}}" unless center = Persons.match_by_login_name(c._login_name)
  return "Error: Passwords do not match for #{c.inspect}" unless center.password_plain == c._password_plain
  courses = Courses.search_by_name("^#{center.login_name}_").collect { |c|
    ret = c.to_hash
    ret._students = c.students.collect { |s| no_center(s, center) }
    ret._ctype = c.ctype.name
    ret._teacher = no_center(c.teacher.login_name, center)
    if c.assistant
      ret._assistant = no_center(c.assistant.login_name, center)
    end
    ret._responsible = no_center(c.responsible.login_name, center)
    ret
  }
  log_msg :ICC_courses, "Returning #{courses}"
  return courses
end
icc_exams(tr) click to toggle source
# File Entities/Course.rb, line 385
def icc_exams(tr)
  tr._tid.gsub!(/[^a-zA-Z0-9_-]/, '')
  file = "/tmp/#{tr._tid}.zip"
  File.open(file, 'w') { |f| f.write Base64::decode64(tr._data._zip) }
  if course = Courses.match_by_name(center_course_name(tr._data._course, tr._user))
    dputs(3) { 'Updating exams' }
    course.zip_read(file)
  end
  "Read file #{file}"
end
icc_exams_here(tr) click to toggle source
# File Entities/Course.rb, line 396
def icc_exams_here(tr)
  course_name = center_course_name(tr._data, tr._user)
  if course = Courses.match_by_name(course_name)
    dputs(3) { "Sending md5 of #{course_name}" }
    course.md5_exams
  else
    dputs(3) { "Didn't find #{course_name}" }
    {}
  end
end
icc_grades(tr) click to toggle source
# File Entities/Course.rb, line 360
def icc_grades(tr)
  tr._data.collect { |grade|
    grade.to_sym!
    ret = [grade._course, grade._student]
    dputs(3) { "Grades is #{grade.inspect}" }
    grade._course =
        Courses.match_by_name("#{tr._user}_#{grade._course}")
    grade._student =
        Persons.match_by_login_name("#{tr._user}_#{grade._student}")
    grade.delete :grade_id
    grade.delete :random
    if g = Grades.match_by_course_person(grade._course,
                                         grade._student)
      dputs(3) { "Updating grade #{g.inspect} with #{grade.inspect}" }
      g.data_set_hash(grade)
    else
      g = Grades.create(grade)
      dputs(3) { "Creating grade #{g.inspect} with #{grade.inspect}" }
    end
    dputs(3) { Grades.match_by_course_person(grade._course,
                                             grade._student).inspect }
    ret.push g.random
  }
end
icc_grades_get(tr) click to toggle source
# File Entities/Course.rb, line 298
def icc_grades_get(tr)
  # dputs_func
  dputs(3) { "Data is #{tr.inspect}" }
  course = Courses.match_by_name(tr._course)
  return "Course #{tr._course} not found" unless course
  course._students.collect{|s|
    if grade = Grades.match_by_course_person(course, s)
      g = grade.to_hash
      g._student = grade.student.login_name.sub(/^#{tr._center}_/, '')
      g
    else
      nil
    end
  }.select{|g| g}
end
icc_users(tr) click to toggle source
# File Entities/Course.rb, line 262
def icc_users(tr)
  users = tr._data
  dputs(3) { "users are #{users.inspect}" }
  users.each { |s|
    s.to_sym!
    if s._login_name != tr._user
      s._login_name = "#{tr._user}_#{s._login_name}"
    else
      s.delete :password
    end
    %w( person_id groups ).each { |f|
      s.delete f.to_sym
    }
    s._permissions = if s._permissions
                       s._permissions & %w( teacher center )
                     else
                       dputs(0) { "User #{s._login_name} has no permissions!" }
                       []
                     end
    dputs(3) { "Person is #{s.inspect}" }
    dputs(4) { "Looking for #{s._login_name}" }
    if stud = Persons.match_by_login_name(s._login_name)
      dputs(3) { "Updating person #{stud.login_name} with #{s._login_name}" }
      stud.data_set_hash(s)
    else
      dputs(3) { "Creating person #{s.inspect}" }
      Persons.create(s)
    end
  }
  "Got users #{users.collect { |u| u._login_name }.join(':')}"
end
list_courses(session=nil) click to toggle source
# File Entities/Course.rb, line 106
def list_courses(session=nil)
  sort_courses(list_courses_raw(session))
end
list_courses_entries(session=nil) click to toggle source
# File Entities/Course.rb, line 110
def list_courses_entries(session=nil)
  sort_courses(list_courses_raw(session).select { |c| c.entries })
end
list_courses_for_person(person) click to toggle source
# File Entities/Course.rb, line 114
def list_courses_for_person(person)
  ln = person.class == String ? person : person.login_name
  dputs(3) { "Searching courses for person #{ln}" }
  ret = @data.values.select { |d|
    dputs(3) { "Searching #{ln} in #{d.inspect} - #{d[:students].index(ln)}" }
    d[:students] and d[:students].index(ln)
  }.collect { |c| Courses.match_by_course_id(c._course_id) }
  dputs(3) { "Found courses #{ret.inspect}" }
  sort_courses(ret)
end
list_courses_raw(session=nil) click to toggle source
# File Entities/Course.rb, line 89
def list_courses_raw(session=nil)
  ret = search_all_
  if session != nil
    user = session.owner
    if not session.can_view('FlagCourseGradeAll')
      ret = ret.select { |d|
        dputs(4) { "teacher is #{d.teacher.inspect}, user is #{user.inspect}" }
        (d.teacher and d.teacher.login_name == user.login_name) or
            (d.responsible and d.responsible.login_name == user.login_name) or
            ((d.name =~ /^#{session.owner.login_name}_/) and
                session.owner.permissions.index('center'))
      }
    end
  end
  ret
end
migration_1(c) click to toggle source
# File Entities/Course.rb, line 230
def migration_1(c)
  name = c.classroom
  if name.class == Array
    name = name.join
  end
  dputs(4) { "Converting for name #{name} with #{Rooms.data.inspect}" }
  r = Rooms.match_by_name(name)
  if (not r) and (not (r = Rooms.match_by_name('')))
    r = nil
  end
  c.classroom = r
  dputs(4) { "New room is #{c.classroom.inspect}" }
end
migration_2_raw(c) click to toggle source
# File Entities/Course.rb, line 244
def migration_2_raw(c)
  %w( teacher assistant responsible ).each { |p|
    person = c[p.to_sym]
    dputs(4) { "#{p} is before #{person.inspect}" }
    if p == 'assistant' and person == ['none']
      person = nil
    else
      begin
        person = Persons.match_by_login_name(person.join).person_id
      rescue NoMethodError
        person = Persons.match_by_login_name('admin').person_id
      end
    end
    dputs(4) { "#{p} is after #{person.inspect}" }
    c[p.to_sym] = person
  }
end
no_center(str, center) click to toggle source
# File Entities/Course.rb, line 407
def no_center(str, center)
  str.sub(/^#{center.login_name}_/, '')
end
set_entry(id, field, value) click to toggle source
Calls superclass method
# File Entities/Course.rb, line 75
def set_entry(id, field, value)
  case field.to_s
    when 'name'
      value.gsub!(/[^a-zA-Z0-9_-]/, '_')
  end
  super(id, field, value)
end
setup_data() click to toggle source
# File Entities/Course.rb, line 19
def setup_data

  value_block :name
  value_entity_courseType_ro_all :ctype, :drop, :name
  value_str :name

  value_block :calendar
  value_date :start
  value_date :end
  value_date :sign
  value_int :duration
  value_list_drop :dow, '%w( lu-me-ve ma-je-sa lu-ve ma-sa )'
  value_list_drop :hours, '%w( 9-12 16-18 9-11 )'
  value_entity_room_all :classroom, :drop, :name

  value_block :students
  value_list :students

  value_block :teacher
  value_entity_person :teacher, :drop, :full_name
  value_entity_person_empty :assistant, :drop, :full_name
  value_entity_person :responsible, :drop, :full_name

  value_block :center
  value_entity_person_empty_all :center, :drop, :full_name

  value_block :content
  value_str :description
  value_text :contents

  value_block :accounting
  value_int :salary_teacher
  value_int :salary_assistant
  value_int :students_start
  value_int :students_finish
  value_int :cost_student
  value_int :entry_total

  value_block :account
  value_entity_account_empty :entries, :drop, :path

  @dir_diplomas = ConfigBase.diploma_dir
  @dir_exams = ConfigBase.exam_dir
  @dir_exams_share = "#{@dir_exams}/Share"

  [@dir_diplomas, @dir_exams, @dir_exams_share].each { |d|
    File.exists? d or FileUtils.mkdir d
  }

  @thread = nil
  @presence_sheet ||= 'presence_sheet.ods'
  @presence_sheet_small ||= 'presence_sheet_small.ods'
  @print_presence = OpenPrint.new("#{@dir_diplomas}/#{@presence_sheet}")
  @print_presence_small = OpenPrint.new("#{@dir_diplomas}/#{@presence_sheet_small}")
end
sort_courses(c) click to toggle source
# File Entities/Course.rb, line 83
def sort_courses(c)
  c.collect { |d| [d.course_id, d.name] }.sort { |a, b|
    a[1].gsub(/.*([0-9]{4}.*)/, '\1') <=> b[1].gsub(/.*([0-9]{4}.*)/, '\1')
  }.reverse
end