gestion 1.9.12

data/Entities/FilesManage.rb

@@ -0,0 +1,226 @@
+# FilesManage holds different classes that store information about the
+# managed files.
+
+class FMDirs < Entities
+  attr_accessor :dir_base
+
+  def create(fields)
+    if search_by_path(fields._name, fields._parent)
+      return
+    end
+    super(fields)
+  end
+
+  def setup_data
+    @dir_base = '/opt/Files'
+    value_str :name
+    # If the parent is empty, this is a top-dir
+    value_str :parent
+  end
+
+  def base_dirs
+    # puts @data
+    return search_by_parent('^$')
+  end
+
+  def sub_dirs(base)
+    name = base
+    if name.class != String
+      name = base._name
+    end
+    return search_by_parent(name)
+  end
+
+  def search_by_path(n, p = nil)
+    if p
+      filter_by(name: "^#{n}$", parent: "^#{p}$").first
+    else
+      find_by_name("^#{n}$")
+    end
+  end
+
+  def self.accents_replace(str)
+    str = str.downcase.gsub(/ /, '_')
+    accents = Hash[*%w( a àáâä e éèêë i ìíîï o òóôöœ u ùúûü c ç ss ß )]
+    dputs(4) { "String was #{str}" }
+    accents.each { |k, v|
+      str.gsub!(/[#{v}]/, k)
+    }
+    str.gsub!(/[^a-z0-9_\.-]/, '_')
+    dputs(4) { "String is #{str}" }
+    str
+  end
+end
+
+class FMDir < Entity
+  def path(*f)
+    p = [name]
+    parent and p.unshift(parent)
+    File.join(FMDirs.dir_base, *p, *f)
+  end
+
+  def sub_dirs
+    return FMDirs.search_by_parent(name)
+  end
+
+  # Returns all entries in that directory
+  def entries
+    return [] unless parent != ''
+    FMEntries.search_all_.select { |e|
+      dir = e._directory
+      dir._parent == parent && dir._name == name
+    }
+  end
+
+  # Searches for files that are not an entry yet, adds them
+  # and returns the array of new entries.
+  def update_files
+    # dputs_func
+    ffiles = []
+    fentries = entries
+    Dir.glob(File.join(path, '*')).each { |f|
+      next if File.directory? f
+      f = File.basename(f)
+      if f !~ /\.file$/
+        dputs(3) { "Found file #{f}" }
+        if fentries.select { |e|
+          dputs(3) { "Checking with #{e._name} / #{e.file_name}" }
+          e.file_name == f
+        }.size == 0
+          f_sanitized = FMDirs.accents_replace(f)
+          if f_sanitized != f
+            File.rename(path(f), path(f_sanitized))
+          end
+          dputs(3) { "Creating entry for #{f}/#{f_sanitized} with dir #{self.inspect}" }
+          desc = ''
+          if f.size > 16
+            desc = f
+            desc.sub(/\..*?$/, '')
+          end
+          ffiles.push FMEntries.create(name: f_sanitized, url_file: "localhost://#{f_sanitized}",
+                                       directory: self, tags: [], description: desc)
+        end
+      end
+    }
+    ffiles
+  end
+
+  # If it's an OS-directory, it adds all its subdirectories that
+  # are not yet stored.
+  def update_dirs
+    return if parent && parent != ''
+    fdirs = []
+    Dir.glob(File.join(path, '*/')).each{|d|
+      d = File.basename(d)
+      if FMDirs.search_by_path(d, name)
+        next
+      end
+      fdirs.push FMDirs.create(name: d, parent: name)
+    }
+    fdirs
+  end
+end
+
+class FMEntries < Entities
+  self.needs %w(FMDirs)
+
+  def setup_data
+    value_str :name
+    value_str :url_file
+    value_str :url_page
+    value_str :description
+    value_entity_FMDir :directory
+    value_str :tags
+    value_bool :changed
+  end
+
+  def load(has_static = true)
+    file_id = 1
+    FMDirs.base_dirs.each { |base|
+      FMDirs.sub_dirs(base._name).each { |sub|
+        Dir.glob(File.join(sub.path, '*.file')).each { |f|
+          lines = IO.readlines(f).collect { |l| l.chomp }
+          tags = lines[7] || ''
+          @data[file_id] = {
+              fmentry_id: file_id,
+              name: File.basename(f),
+              url_file: lines[0],
+              url_page: lines[1],
+              description: lines[3],
+              directory: sub,
+              tags: tags.split(',').map{|t| t.sub(' ', '')},
+              changed: false,
+          }
+          file_id += 1
+        }
+      }
+    }
+  end
+
+  def save
+    FMEntries.search_all_.each { |e|
+      e.save_file
+    }
+  end
+
+  def create(*args)
+    e = super(*args)
+    e._changed = true
+    e._name = e.file_name + '.file'
+    e.save_file
+    e
+  end
+
+  def search_by_directory(dir)
+    FMEntries.search_all_.select{|e|
+      d = e._directory
+      d._name == dir._name && d._parent == dir._parent
+    }
+  end
+end
+
+
+class FMEntry < Entity
+  def save_file(force = false)
+    if changed == true || force
+      if !tags || tags == ''
+        self._tags = []
+      end
+      File.open(directory.path(name), 'w') { |f|
+        f.write("#{url_file}\n#{url_page}\n\n#{description}\n\n"+
+                    "#{directory._parent}\n#{directory._name}\n" +
+                    "#{tags.join(', ')}")
+      }
+      self.changed = false
+    end
+  end
+
+  def file_name
+    if !url_file
+      return name.chomp('.file')
+    end
+    if url_file =~ /^:(.*?):/
+      return $1
+    end
+    File.basename url_file
+  end
+
+  def full_path
+    return File.join(directory.path, name)
+  end
+
+  def delete
+    FileUtils.rm_f File.join(directory.path, file_name)
+    FileUtils.rm_f File.join(directory.path, name)
+    super
+  end
+
+  def rename(new_name)
+    nname = FMDirs.accents_replace(new_name)
+    File.rename(directory.path(file_name), directory.path(nname))
+    File.rename(full_path, directory.path(nname+'.file'))
+    self.name = nname + '.file'
+    self.url_file = "http://localhost/#{nname}"
+    save_file(true)
+  end
+end

data/Entities/Grade.rb

@@ -0,0 +1,186 @@
+class Grades < Entities
+
+  def setup_data
+    value_entity_course :course
+    value_entity_person :student
+    value_int :random
+
+    value_block :info
+    value_list_int :means
+    value_int :mean
+    value_str :remark
+  end
+
+  def match_by_course_person(course, student)
+    # dputs_func
+    if course.class != Course
+      course = Courses.match_by_course_id(course)
+    end
+    if student.class != Person
+      student = Persons.match_by_login_name(student)
+    end
+    if course && student
+      dputs(4) { "Found #{course.name} - #{student.login_name}" }
+      grades = Grades.matches_by_course(course.course_id)
+      grades.each { |g|
+        dputs(4) { "Checking grade #{g.student}-#{g}-#{student}" }
+        if g.student == student
+          dputs(4) { "Found grade #{g} for #{student.login_name} in #{course.name}" }
+          return g
+        end
+      }
+    end
+    return nil
+  end
+
+  def save_data(d)
+    #dputs_func
+    if not d.has_key? :grade_id
+      id = matches_by_course(d[:course].course_id).select { |g|
+        g.student == d[:student]
+      }
+      if id.length > 0
+        dputs(2) { "Saving grade with existing id of #{id}" }
+        d[:grade_id] = id[0].grade_id
+      end
+    end
+    dputs(4) { "data is #{d.inspect}" }
+    if d._means.count > 0
+      d[:mean] = d[:means].reduce(:+) / d[:means].count
+      dputs(4) { "data is #{d.inspect}" }
+    else
+      d._mean = 0
+    end
+    dputs(4) { "data before storing is #{d.inspect}" }
+    super(d)
+  end
+
+  def self.grade_to_mean(g)
+    case g
+      when /P/ then
+        10
+      when /AB/ then
+        13
+      when /B/ then
+        15
+      when /TB/ then
+        17
+      when /E/ then
+        19
+      else
+        9
+    end
+  end
+
+  def migration_1_raw(g)
+    course = Courses.match_by_course_id(g._course_id)
+    if course and course.ctype
+      g._means = [g._mean || 0] * course.ctype.tests_nbr.to_i
+      dputs(4) { "means is #{g._means.inspect} - tests are #{course.ctype.tests_nbr.inspect}" }
+    else
+      dputs(0) { "Error: Migrating without ctype for #{g.inspect}..." }
+      exit
+    end
+  end
+
+  def migration_2_raw(g)
+    g._course = g._course_id
+    g._student = g._person_id
+  end
+
+  def self.create(data)
+    grade = super(data)
+    data._means and grade.means = data._means
+    grade
+  end
+end
+
+class Grade < Entity
+  def setup_instance
+    if ConfigBase.has_function? :course_server
+      init_random
+    end
+  end
+
+  def to_s
+    begin
+      value = (data_get(:mean).to_f * 2).round / 2
+    rescue FloatDomainError => _e
+      return 'NP'
+    end
+
+    case value
+      when 10..11.5 then
+        'P'
+      when 12..13 then
+        'AB'
+      when 14..15.5 then
+        'B'
+      when 16..17.5 then
+        'TB'
+      when 18..20 then
+        'E'
+      else
+        'NP'
+    end
+  end
+
+  def mention
+    case to_s
+      when 'P' then
+        'Passable'
+      when 'AB' then
+        'Assez bien'
+      when 'B' then
+        'Bien'
+      when 'TB' then
+        'Très bien'
+      when 'E' then
+        'Excellent'
+      else
+        'PAS PASSÉ'
+    end
+  end
+
+  def init_random
+    while not self.random
+      r = rand(1_000_000_000).to_s.rjust(9, '0')
+      Grades.match_by_random(r) or self.random = r
+    end
+  end
+
+  def get_url_label
+    # dputs_func
+    init_random
+    dputs(4) { "Course is #{course.inspect}" }
+    center_id = course.center ? course.center.login_name : 'pit'
+    dputs(4) { "Course is #{course.inspect}" }
+    "#{ConfigBase.get_url(:label_url)}/#{center_id}/#{random}"
+  end
+
+  def person
+    dputs(0) { "Error: Deprecated - use student in #{caller.inspect}" }
+    student
+  end
+
+  def means=(m)
+    if m != self._means
+      if ConfigBase.has_function? :course_client
+        self.random = nil
+      end
+    end
+    if m
+      self._means = m.collect { |v| [20.0, [0.0, v.to_f].max].min }
+      self._mean = means.reduce(:+).to_f / m.count.to_f
+    end
+  end
+
+  def remark=(r)
+    if r != self._remark
+      if ConfigBase.has_function? :course_client
+        self.random = nil
+      end
+    end
+    self._remark = r
+  end
+end

data/Entities/Internet.rb

@@ -0,0 +1,300 @@
+=begin rdoc
+=== Internet
+
+This module links the following external parts:
+* Network::Device - to handle internet-captive devices
+* Monitor::Traffic - to watch individual traffic from users
+
+To use it, call the #setup method, which will list all devices and start
+listening for new ones.
+=end
+
+# Holds the different type of users with regard to internet.
+# TODO: add limit_class and limit_course to +type+
+class InternetClasses < Entities
+  def setup_data
+    value_str :name
+    value_int :limit
+    value_list_drop :type, '%w(unlimited limit_daily_mo limit_daily_min)'
+  end
+
+  def migration_1_raw(i)
+    i._type == ['limit_daily'] and i._type = ['limit_daily_mo']
+    i._limit = i._limit_mo
+  end
+end
+
+# Represents one usage-type
+class InternetClass < Entity
+  # Checks whether a given user is in limits of InternetClasses and thus
+  # allowed to use the internet
+  def in_limits?(login, today = Date.today)
+    return true if type == ['unlimited']
+    return true unless t = Network::Captive.traffic
+    t.get_day(login, 1, today.to_time).flatten[0..1].inject(:+) < limit.to_i * 1_000_000
+  end
+end
+
+class InternetPersons < Entities
+  def setup_data
+    value_entity_person :person
+    value_entity_internetClasses :iclass
+    value_date :start
+    value_int :duration
+  end
+end
+
+class InternetPerson < Entity
+  # checks whether that person has an active reference to #InternetClasses
+  def is_active?(today = Date.today)
+    duration.to_i == 0 ||
+        (start.to_s != '' && (Date.from_web(start) + duration.to_i > today))
+  end
+
+  # checks whether a person is active and in limits
+  def in_limits?(today = Date.today)
+    is_active?(today) && iclass.in_limits?(person.login_name, today)
+  end
+end
+
+module Internet
+  attr_accessor :device
+  extend self
+  include Network
+
+  @operator_local = nil
+
+  # Gets all devices and adds an observer for new devices. Also sets up
+  # traffic-tables for users, loading if some already exist
+  def setup
+    #dputs_func
+    @traffic_save = Statics.get(:GestionTraffic)
+    dputs(4) { "@traffic is #{@traffic_save.data_str}" }
+    if ConfigBase.has_function?(:internet_captive)
+      @device = nil
+
+      Device.add_observer(self)
+      dev, op = if (dev_id = ConfigBase.captive_dev.to_s).length > 0
+                  dev_id.sub!(/:.*$/, '')
+                  dputs(2) { "Searching for #{dev_id} in #{Network::Device.list}" }
+                  [Network::Device.search_dev({uevent: {interface: dev_id}}).first,
+                   'add_captive']
+                else
+                  [Network::Device.search_dev({uevent: {driver: 'option'}}).first, 'add']
+                end
+      dev and update(op, dev)
+    end
+  end
+
+  # Whenever a new device or a new operator is detected, this function
+  # updates the internal variables.
+  def update(operation, dev = nil)
+    dputs(3) { "Updating operation #{operation} with dev #{dev.inspect}" }
+    case operation
+      when /del/
+        if @device == dev
+          log_msg :Internet, "Lost device #{@device}"
+          @device.delete_observer(self)
+          @device = nil
+          Captive.accept_all
+        end
+      when /add/
+        if dev && dev.dev._uevent && dev.dev._uevent._driver == 'option' ||
+            operation == 'add_captive'
+          @device = dev
+          @device.add_observer(self)
+          @operator_local = @device.operator
+          @operator_local and Captive.setup(@device, @traffic_save.data_str)
+          log_msg :Internet, "Got new device #{@device}"
+        else
+          log_msg :Internet, "New device #{dev} that doesn't match option"
+        end
+      when /operator/
+        @operator_local = @device.operator
+        Captive.setup(@device, @traffic_save.data_str)
+        log_msg :Internet, "Got new operator #{@operator_local}"
+    end
+  end
+
+  # Scans all connected users and deduces money from all connected, non-free
+  # users. If there is not enough money left, it kicks the user.
+  def take_money
+    #dputs_func
+    return unless @operator_local
+
+    Captive.cleanup
+    Captive.users_connected.each { |u|
+      HelperClasses::System.rescue_all do
+        dputs(3) { "User is #{u}" }
+        cost = @operator_local.user_cost_now.to_i
+
+        dputs(3) { "ISP is #{@operator_local.name} and conn_type is "+
+            "#{@operator_local.connection_type}" }
+        user = Persons.match_by_login_name(u)
+        if user
+          dputs(3) { "Found user #{u}: #{user.full_name}" }
+          if not (ag = AccessGroups.allow_user_now(u))[0]
+            log_msg 'take_money', "Kicking user #{u} because of accessgroups: #{ag[1]}"
+            user_disconnect user.login_name
+          elsif self.free(user)
+            dputs(2) { "User #{u} goes free" }
+            Captive.user_keep(user.login_name, ConfigBase.keep_idle_free.to_i)
+          elsif @device.connection_status == Device::CONNECTED
+            dputs(3) { "User #{u} will pay #{cost}" }
+            if user.internet_credit.to_i >= cost
+              dputs(3) { "Taking #{cost} internet_credits from #{u} who has #{user.internet_credit}" }
+              user.internet_credit = user.internet_credit.to_i - cost
+            else
+              log_msg 'take_money', "User #{u} has not enough money left - kicking"
+              user_disconnect user.login_name
+            end
+          end
+        else
+          dputs(0) { "Error: Captive said #{u} is connected, but couldn't find that user!" +
+              " Users connected: #{Captive.users_connected.inspect}" }
+        end
+      end
+    }
+  end
+
+  def connection_status
+    return [ 0, "No device" ] unless @device
+    if ConfigBase.connection_status_log && ConfigBase.connection_status_log.length > 0
+      reply = System.run_str("cat #{ConfigBase.connection_status_log}")
+      if reply.length > 0
+        return reply.split(" ")
+      else
+        return [ 2, "Error: #{reply}" ]
+      end
+    else
+      if @device.connection_status == Device::CONNECTED
+        return [ 4, "Up" ]
+      else
+        return [ 2, "Connecting" ]
+      end
+    end
+  end
+
+  # Scan for all active courses (date_start <= date_now <= date_end) for a
+  # specific +user+, which should be of type #Persons
+  def active_course_for(user)
+    # We want an exact match, so we put the name between ^ and $
+    courses = Courses.search_by_students("^#{user.login_name}$")
+    if courses
+      dputs(3) { "Courses : #{courses.inspect}" }
+      courses.each { |c|
+        dputs(3) { "Searching course #{c}" }
+        if c.name and c.start and c.end
+          dputs(3) { "Searching course for #{user.full_name}" }
+          dputs(3) { [c.name, c.start, c.end].inspect }
+          begin
+            c_start = Date.strptime(c.start, '%d.%m.%Y')
+            c_end = Date.strptime(c.end, '%d.%m.%Y')
+          rescue
+            c_start = c_end = Date.new
+          end
+          if c_start <= Date.today and Date.today <= c_end
+            return true
+          end
+        end
+      }
+    end
+    return false
+  end
+
+  # Decides whether a person is allowed to surf for free, depending on:
+  # - ConfigBase.allow_free ('all' - 'false' - 'true')
+  # - permissions (FlagInternetFree and internet_free_staff)
+  # - freesurf-group
+  # - courses (date between :start and :end and internet_free_course)
+  # - InternetPersons, where the different allowed traffics might be stored
+  def free(user)
+    # dputs_func
+    case ConfigBase.allow_free[0]
+      when /all/
+        dputs(3) { "User #{user} is free because ALL are free" }
+        return true
+      when /false/
+        dputs(3) { "User #{user} is NOT free because NONE are free" }
+        return false
+    end
+    if user.class != Person
+      user = Persons.match_by_login_name(user)
+      dputs(4) { "Found user #{user.login_name}" }
+    end
+    login = user.login_name
+    if user
+      dputs(3) { "Searching groups for user #{login}: #{user.groups.inspect}" }
+      if user.groups && user.groups.index('freesurf')
+        dputs(3) { "User #{login} is on freesurf" }
+        return true
+      end
+
+      if ConfigBase.has_function?(:internet_free_staff) &&
+          Permission.can_view(user.permissions, 'FlagInternetFree')
+        dputs(3) { "User #{login} has FlagInternetFree" }
+        return true
+      end
+
+      if ConfigBase.has_function?(:internet_free_course) &&
+          self.active_course_for(user)
+        dputs(3) { "User #{login} is free for a course" }
+        return true
+      end
+
+      if (ip = InternetPersons.match_by_person(user)) && ip.iclass
+        dputs(3) { "User #{login} has internetpersons #{ip.in_limits?}" }
+        return ip.in_limits?
+      end
+
+      Activities.search_by_tags('internet').each { |act|
+        dputs(3) { "Searching activity #{act}" }
+        if act.start_end(user) != [nil, nil]
+          if (il = act.internet_limit) == nil
+            dputs(3) { "User #{user.login_name} goes free" }
+            return true
+          else
+            dputs(3) { "found limit #{il} for user #{user.login_name}" }
+            return il.in_limits?(user.login_name)
+          end
+        end
+      }
+
+      if ic = ConfigBase.iclass_default
+        dputs(3) { "User #{login} falls into default : #{ic.in_limits?(login)}" }
+        return ic.in_limits?(login)
+      end
+    end
+    dputs(3) { 'Found nothing' }
+    return false
+  end
+
+  # Fetches new traffic and saves the actual traffic in Statics
+  def update_traffic
+    return unless Captive.traffic
+    Captive.traffic.update
+    @traffic_save.data_str = Captive.traffic.to_json
+  end
+
+  def operator
+    # Wow - this is really ugly. Why do two different listeners (Internet and MobileControl)
+    # don't agree on who is the operator?
+    return @operator_local unless $MobileControl
+    $MobileControl.operator
+  end
+
+  # Lets a user connect and adds its IP to the traffic-table
+  def user_connect(name, ip)
+    return unless @operator_local
+
+    # Free users have different auto-disconnect time than non-free users
+    Captive.user_connect name, ip, (self.free(name) ? 'yes' : 'no')
+  end
+
+  # Disconnects the user and removes its IP from the traffic-table
+  def user_disconnect(name)
+    return unless @operator_local
+
+    Captive.user_disconnect_name name
+  end
+end