gestion 1.9.12

data/Views/Course/Students.rb

@@ -0,0 +1,92 @@
+# Manages grades of a course
+# - Add or change grades
+# - Print out grades
+
+class CourseStudents < View
+  def layout
+    set_data_class :Courses
+
+    @update = true
+    @order = 30
+
+    gui_hboxg do
+      gui_vboxg :nogroup do
+        show_list_single :students, :width => 300, :callback => true, :flexheight => 1
+      end
+      gui_vbox :nogroup do
+        gui_vbox :nogroup do
+          show_str :first_name, :width => 150
+          show_str :family_name
+          show_list_drop :gender, '%w( male female n/a )'
+          show_button :save
+        end
+      end
+    end
+  end
+
+  def rpc_update(session)
+    super(session) +
+        reply(:empty_nonlists, [:students])
+  end
+
+  def update_student(data)
+    c_id, p_name = data._courses[0], data._students[0]
+    if p_name and c_id
+      person = Persons.match_by_login_name(p_name)
+      update_form_data(person)
+    else
+      []
+    end
+  end
+
+  def rpc_list_choice(session, name, data, select = nil)
+    dputs(3) { "rpc_list_choice with #{name} - #{data.inspect}" }
+    ret = []
+    course_id = data._courses[0]
+    course = Courses.match_by_course_id(course_id)
+    case name
+      when 'courses'
+        if course
+          dputs(3) { 'replying' }
+          ret = rpc_update(session) +
+              reply(:empty_nonlists, :students) +
+              update_form_data(course) +
+              reply(:update, {:courses => [course_id]})
+          ls = course.list_students
+          if course.students.size > 0 && ls.size > 0
+            first = if select
+                      # Fetch the next element, first one if it was the last one
+                      ls[((0...ls.length).find{ |i|
+                           ls[i][0] == select
+                         }.to_i + 1) % ls.length][0]
+                    else
+                      course.list_students[0][0]
+                    end
+            ret += reply(:update, {:students => [first]})
+          end
+
+          dputs(4) { "Course is #{course} - ret is #{ret.inspect}" }
+        end
+      when 'students'
+        ret += update_student(data)
+    end
+
+    ret
+  end
+
+  def rpc_button_save(session, data)
+    dputs(3) { "Data is #{data.inspect}" }
+    c_id, p_name = data._courses.first, data._students.first
+    course = Courses.match_by_course_id(c_id)
+    student = Entities.Persons.match_by_login_name(p_name)
+    if course and student
+      if data._first_name
+        Entities.Persons.save_data({:person_id => student.person_id,
+                                    :first_name => data._first_name,
+                                    :family_name => data._family_name,
+                                    :gender => data._gender})
+      end
+      rpc_list_choice(session, 'courses', data, p_name)
+    end
+  end
+end

data/Views/Course/Tabs.rb

@@ -0,0 +1,220 @@
+class CourseTabs < View
+  def layout
+    @order = 20
+    @update = true
+    @functions_need = [:courses]
+
+    gui_vbox :nogroup do
+      show_str :search_txt
+      show_list_single :courses, :flexheight => 1, :callback => true,
+                       :width => 100
+      show_button :search, :delete, :add, :import
+    end
+
+    gui_window :error do
+      show_html "<h1>You're not allowed to do that</h1>"
+      show_button :close
+    end
+
+    gui_window :not_all_elements do
+      gui_vbox do
+        gui_vbox :nogroup do
+          show_str :ct_name
+          show_int :ct_duration
+          show_str :ct_desc
+          show_text :ct_contents
+          show_list_drop :ct_filename, 'CourseTypes.files'
+        end
+        gui_vbox :nogroup do
+          show_str :new_room
+          show_str :new_teacher
+          show_str :new_center
+        end
+        show_button :add_missing, :close
+      end
+    end
+
+    gui_window :add_course do
+      gui_hbox :nogroup do
+        gui_vbox :nogroup do
+          show_entity_courseType_all :new_ctype, :drop, :name
+          show_str :name_date
+          show_entity_person :new_center_course, :drop, :full_name
+          show_button :new_course, :close
+        end
+      end
+
+      gui_window :win_confirm do
+        show_html :confirm_delete_txt
+        show_button :confirm_delete, :close
+      end
+    end
+  end
+
+  def rpc_update(session)
+    hide = []
+    if CourseTypes.data.size > 0
+      hide.push :ct_name, :ct_duration, :ct_desc, :ct_contents, :ct_filename
+    end
+    if Rooms.data.size > 0
+      hide.push :new_room
+    end
+    if (teachers = Persons.list_teachers).size > 0
+      session.owner.permissions
+      if (!session.owner.permissions.index('center')) ||
+          teachers.select { |t| t =~ /^#{session.owner.login_name}_/ }.length > 0
+        hide.push :new_teacher
+      end
+    end
+    if Persons.find_by_permissions(:center)
+      hide.push :new_center
+    end
+    if hide.size < 8
+      (reply(:window_show, :not_all_elements) +
+          hide.collect { |h| reply(:hide, h) }).flatten
+    else
+      rep = reply(:empty_nonlists, [:courses]) +
+          reply(:update, :courses => Courses.list_courses(session))
+      if not session.can_view('FlagAdminCourse')
+        rep += reply(:hide, :delete) + reply(:hide, :add)
+      end
+      rep + reply(:hide, :import) + reply(:focus, :search_txt)
+    end
+  end
+
+  def rpc_button_add_missing(session, args)
+    args.to_sym!
+    dputs(5) { args.inspect }
+    if args._ct_name and args._ct_name.size > 0
+      dputs(3) { 'Creating CourseType' }
+      ct = CourseTypes.create(:name => args._ct_name, :duration => args._ct_duration,
+                              :tests_str => 'Mean', :description => args._ct_desc,
+                              :contents => args._ct_contents,
+                              :diploma_type => ['simple'], :output => ['certificate'],
+                              :page_format => [1], :file_diploma => args._ct_filename)
+      dputs(1) { "New CourseType is #{ct.inspect}" }
+    end
+    if args._new_room and args._new_room.size > 0
+      dputs(3) { 'Creating Room' }
+      room = Rooms.create(:name => args._new_room)
+      dputs(1) { "New room is #{room.inspect}" }
+    end
+    if args._new_teacher and args._new_teacher.size > 0
+      dputs(3) { 'Creating Teacher' }
+      teacher = Persons.create_person(args._new_teacher, session.owner)
+      teacher.permissions = ['teacher']
+      dputs(1) { "New teacher #{teacher.inspect}" }
+    end
+    if args._new_center and args._new_center.size > 0
+      dputs(3) { 'Creating Center' }
+      center = Persons.create(:complete_name => args._new_center)
+      center.permissions = ['center']
+      dputs(1) { "New center #{center.inspect}" }
+    end
+    reply(:window_hide) +
+        rpc_update(session) +
+        rpc_update_view(session) +
+        reply(:pass_tabs, [:update_hook])
+  end
+
+  def rpc_button_delete(session, args)
+    if not session.can_view('FlagAdminCourse')
+      return reply(:window_show, :error)
+    end
+    dputs(3) { "session, data: #{[session, args.inspect].join(':')}" }
+    course = Courses.match_by_course_id(args['courses'][0])
+    dputs(3) { "Got #{course.name} - #{course.inspect}" }
+    if course
+      return reply(:window_show, :win_confirm) +
+          reply(:update, :confirm_delete_txt => 'Do you really want to delete<br>' +
+                           "course #{course.name}?")
+    end
+  end
+
+  def rpc_button_confirm_delete(session, args)
+    if not session.can_view('FlagAdminCourse')
+      return reply(:window_show, :error)
+    end
+    dputs(3) { "session, data: #{[session, args.inspect].join(':')}" }
+    course = Courses.match_by_course_id(args['courses'][0])
+    dputs(3) { "Got #{course.name} - #{course.inspect}" }
+    if course
+      dputs(2) { "Deleting entry #{course}" }
+      log_msg :Course, "User #{session.owner.login_name} deletes course #{course.name}"
+      course.delete
+      course.changed = true
+    end
+
+    reply(:empty_nonlists, [:courses]) +
+        reply(:update, {:courses => Courses.list_courses(session)}) +
+        reply(:child, reply(:empty_nonlists, [:students])) +
+        reply(:window_hide)
+  end
+
+  def rpc_button_new_course(session, data)
+    dputs(3) { "session: #{session} - data: #{data.inspect}" }
+
+    course = Courses.create_ctype(data._new_ctype, data._name_date,
+                                  session.owner)
+
+    if session.owner.permissions.index('center')
+      course.teacher = course.responsible = Persons.responsibles_raw.select { |p|
+        p.login_name =~ /^#{session.owner.login_name}_/ }.first
+    else
+      course.teacher = Persons.find_by_permissions('teacher')
+      course.responsible = Persons.find_by_permissions('director') ||
+          course.teacher
+    end
+
+    log_msg :coursetabs, "Adding new course #{course.inspect}"
+
+    reply(:window_hide) +
+        rpc_update(session) +
+        reply(:update, :courses => [course.course_id])
+  end
+
+  def rpc_button_add(session, data)
+    reply(:window_show, :add_course) +
+        reply(:update, :name_date => "#{Date.today.strftime('%y%m')}") +
+        if ConfigBase.has_function?(:course_server) &&
+            session._owner.has_role(:admin)
+          reply(:show, :new_center_course) +
+              reply(:empty_update, :new_center_course => Persons.centers.
+                                     collect{|c| c.to_list_id})
+        else
+          reply(:hide, :new_center_course)
+        end
+  end
+
+  def rpc_button_close(session, data)
+    reply(:window_hide)
+  end
+
+  def rpc_button_search(session, data)
+    txt = data._search_txt
+    return unless txt.to_s.length >= 2
+    courses = Courses.search_all_.select{|c|
+      c.name + (c.ctype ? c.ctype.name : '') + c.students.to_s +
+          [c.teacher, c.responsible].collect{|p| p && p.full_login}.join =~ /#{txt}/i
+    }
+    reply(:empty_nonlists, [:courses]) +
+        reply(:update, :courses => Courses.sort_courses(courses))
+  end
+
+  def rpc_list_choice(session, name, args)
+    dputs(3) { "New choice #{name} - #{args.inspect}" }
+
+    reply(:pass_tabs, ['list_choice', name, args]) +
+        reply(:fade_in, :parent_child)
+  end
+
+  def rpc_list_choice_sub(session, name, args)
+    dputs(3) { "Sub-tab called with #{name}" }
+  end
+
+  def rpc_update_view(session, args = nil)
+    super(session, args) +
+        reply(:fade_in, 'parent,windows') +
+        reply(:focus, :search_txt)
+  end
+end

data/Views/Internet/Access.rb

@@ -0,0 +1,134 @@
+class InternetAccess < View
+  include VTListPane
+
+  def layout
+    @order = 500
+    @functions_need = [:internet, :network_pro]
+
+    set_data_class :AccessGroups
+
+    gui_hbox do
+      gui_vbox :nogroup do
+        vtlp_list :groups, :name
+        show_button :new, :delete
+      end
+      gui_vbox :nogroup do
+        show_field :name
+        show_field :action
+        show_field :priority
+        show_field :limit_day_mo
+        show_list_single :access_times_view
+        show_fromto :time
+        show_button :save, :add_time, :delete_time
+      end
+      gui_vbox :nogroup do
+        show_list_single :members_view
+        show_str :login_name
+        show_button :add_member, :delete_member
+      end
+    end
+  end
+
+  def update_access_times(group)
+    ats = if group.access_times and (group.access_times.size > 0)
+            group.access_times
+          else
+            ['Always']
+          end
+    reply(:empty, [:access_times_view]) +
+        reply(:update, :access_times_view => ats)
+  end
+
+  def update_members(group)
+    if group and group.members
+      members = group.members.collect { |m|
+        if member = Persons.match_by_login_name(m)
+          name = member.full_name
+          name.to_s == 0 and name = member.login_name
+          [member.login_name, name]
+        else
+          []
+        end
+      }
+    else
+      members = []
+    end
+    members.size == 0 and members = [[0, 'All users']]
+    return reply(:empty_update, :members_view => members)
+  end
+
+  def rpc_button_new(session, data)
+    reply(:empty_nonlists, [:access_times_view]) +
+        update_members(nil) +
+        vtlp_update_list(session)
+  end
+
+  def rpc_button_add_time(session, data)
+    rep = rpc_button_save(session, data)
+    if group = AccessGroups.match_by_name(data._name)
+      if not group.access_times
+        group.access_times = []
+      end
+      time = data['time'].join(';')
+      if not group.access_times.index(time)
+        group.access_times += [time]
+      end
+      rep += update_access_times(group)
+    end
+    return rep
+  end
+
+  def rpc_button_delete_time(session, data)
+    if (group = AccessGroups.match_by_accessgroup_id(data._groups[0])) and
+        (time = data['access_times_view'][0]) and
+        group.access_times
+      group.access_times.delete(time)
+      update_access_times(group)
+    end
+  end
+
+  def rpc_button_add_member(session, data)
+    if (person = Persons.match_by_login_name(data._login_name)) and
+        (group = AccessGroups.match_by_accessgroup_id(data._groups[0]))
+      dputs(3) { "Found person #{person.inspect} and group #{group.inspect}" }
+      if not group.members
+        group.members = []
+      end
+      if not group.members.index person.login_name
+        group.members.push person.login_name
+      end
+      update_members(group) +
+          reply(:empty, :login_name)
+    end
+  end
+
+  def rpc_button_delete_member(session, data)
+    if (person = Persons.match_by_login_name(data._members_view[0])) and
+        (group = AccessGroups.match_by_accessgroup_id(data._groups[0]))
+      group.members.delete person.login_name
+      update_members(group)
+    end
+  end
+
+  alias_method :rpc_button_save_old, :rpc_button_save
+
+  def rpc_button_save(session, data)
+    rpc_button_save_old(session, data) +
+        reply(:empty, [:access_times_view, :members_view])
+  end
+
+  alias_method :rpc_list_choice_old, :rpc_list_choice
+
+  def rpc_list_choice(session, name, data)
+    case name
+      when /groups/
+        ret = rpc_list_choice_old(session, name, data)
+        if group = AccessGroups.match_by_accessgroup_id(data._groups[0])
+          ret += update_access_times(group) + update_members(group)
+        else
+          ret += reply(:empty, :access_times_view)
+        end
+        return ret
+    end
+  end
+end

data/Views/Internet/ClassEdit.rb

@@ -0,0 +1,24 @@
+class InternetClassEdit < View
+  include VTListPane
+
+  def layout
+    set_data_class :InternetClasses
+    @order = 400
+
+    gui_hbox do
+      gui_vbox :nogroup do
+        vtlp_list :classes, :name
+        show_button :new, :delete
+      end
+      gui_vbox :nogroup do
+        show_block :default
+        show_arg :type, callback: true
+        show_button :save
+      end
+    end
+  end
+
+  def rpc_list_choice_type(session, data)
+    reply_visible(data._type.first == 'limit_daily', :limit_mo)
+  end
+end

data/Views/Internet/ClassUsers.rb

@@ -0,0 +1,81 @@
+=begin rdoc
+Allows to edit and add users with regard to InternetClass, so they only can
+use a certain amount of bytes per day.
+
+TODO: make a working add-button
+=end
+
+class InternetClassUsers < View
+  def layout
+    @order = 300
+    @update = true
+
+    gui_hbox do
+      gui_vbox :nogroup do
+        show_str :search_str
+        show_entity_person :persons, :single, :login_name, callback: true
+        show_button :search #, :add
+      end
+      gui_vbox :nogroup do
+        show_entity_internetClass_empty_all :iclass, :drop, :name
+        show_date :start
+        show_int :duration
+        show_button :save
+      end
+
+      gui_window :add_win do
+        show_str :add_full_name
+        show_str :add_login_name
+        show_entity_internetClass_empty_all :add_iclass, :drop, :name
+        show_date :add_date
+        show_int :add_duration
+        show_button :add_user
+      end
+    end
+  end
+
+  def rpc_button_add(session, data)
+    reply(:window_show)
+  end
+
+  def rpc_update(session)
+    return unless t = Network::Captive.traffic
+    list = t.traffic.collect { |h, _k|
+      [h, t.get_day(h, 1).inject(:+)]
+    }.sort_by { |t| t[1] }.reverse[0..10].
+        select{|t| Persons.match_by_login_name(t[0])}.collect { |t|
+      p = Persons.match_by_login_name t[0]
+      p.to_list_id(session.owner)
+    }
+    reply(:empty_update, persons: list)
+  end
+
+  def rpc_button_search(session, data)
+    return unless (str = data._search_str).length > 2
+    list = Persons.data.select { |k, v|
+      "#{v._login_name} #{v._first_name} #{v._family_name}" =~ /#{str}/ }
+    return reply(:empty, :persons) unless list.length > 0
+    list = list.sort_by { |k, v| (v._login_name <=> str).to_i.abs }[0..19].
+        collect { |k, v| Persons.get_data_instance(k) }.
+        collect { |p| [p.person_id, "#{p.full_name} - #{p.login_name}"] }
+    reply(:empty_update, persons: list + [list.first[0]])
+  end
+
+  def rpc_list_choice_persons(session, data)
+    ret = reply(:empty, %w(start duration)) +
+        reply(:update, iclass: [0])
+    ip = InternetPersons.match_by_person(data._persons)
+    return ret unless ip
+    ret + reply(:update, ip.to_hash)
+  end
+
+  def rpc_button_save(session, data)
+    ip = InternetPersons.match_by_person(data._persons.person_id) ||
+        InternetPersons.create(person: data._persons)
+    ip.data_set_hash(data)
+    if data._start.to_s == ''
+      ip.start = nil
+    end
+  end
+
+end

data/Views/Internet/Config.rb

@@ -0,0 +1,32 @@
+class InternetConfig < View
+  def layout
+    set_data_class :ConfigBases
+    #@visible = false
+    @order = 200
+    @update = true
+    @functions_need = [:network, :internet]
+
+    gui_vbox do
+      gui_hbox :nogroup do
+        gui_vbox :nogroup do
+          show_block :operator
+          show_block :internet
+          show_block :captive_conn
+        end
+        gui_vbox :nogroup do
+          show_block :mobilecontrol
+        end
+      end
+      show_button :save_costs
+    end
+  end
+
+  def rpc_button_save_costs(session, data)
+    ConfigBase.data_set_hash(data)
+    ConfigBase.send_config
+  end
+
+  def update(session)
+    ConfigBase.to_hash
+  end
+end