gestion 1.9.12

data/Paths/Info.rb

@@ -0,0 +1,114 @@
+# Used for returning some information about the internal state
+# SHOULD NOT CHANGE ANYTHING IN HERE, JUST READING, INFORMATION!
+
+class Info < RPCQooxdooPath
+  def self.parse_req( req )
+    dputs( 4 ){ "in QVInfo: #{req.inspect}" }
+    self.parse( req.request_method, req.path, req.query, RPCQooxdooHandler.get_ip( req ) )
+  end
+
+  def self.parse( m, p, q, ip )
+    dputs( 2 ){ "in QVInfo: #{m.inspect} - #{p} - #{q.inspect} - #{ip}" }
+    method = p.gsub( /^.info./, '' )
+    dputs( 3 ){ "Calling method #{method}" }
+    if self.respond_to? method.to_sym
+      self.send( method, q.to_sym, ip )
+    else
+      dputs(0){ "Error: method #{method} not in Info" }
+      ''
+    end
+  end
+
+  def self.date(args)
+    dputs( 3 ){ "Arguments are: #{args.inspect}" }
+    return Time.new.to_s
+  end
+  
+  # We allow login for everybody. Things to do:
+  # Check on room (info1, info2, others), course and time
+  def self.allowed_login(args)
+    username = args[:user]
+    return 'yes'
+  end
+  
+  # Who is allowed to use internet for free?
+  # For the moment everybody in a course that didn't end yet
+  def self.internet_free(args)
+    dputs( 3 ){ "Can #{args} do it?" }
+    username = args[:user]
+    user = Entities.Persons.match_by_login_name( username )
+    Internet.free( user ) ? 'yes' : 'no'
+  end
+  
+  def self.isAllowed( args, ip )
+    dputs(3){"isAllowed for #{args.inspect} in #{ip}"}
+    return "yes"
+  end
+  
+  def self.login( args, ip )
+    dputs(3){"Logging in with #{args.inspect}"}
+    user = Persons.match_by_login_name( args[:user] )
+    if self.autoConnect( args, ip ) == 'yes'
+      dputs(2){"Auto-connecting user #{user.login_name} with ip #{ip}"}
+      Internet.user_connect( user.login_name, ip )
+      return 'connected'
+    end
+    return 'nothing'
+  end
+
+  def self.clientUse( args, ip )
+    #return "nopay"
+    dputs(3){"Client use with #{args.inspect}"}
+    user = Persons.match_by_login_name( args[:user] )
+    if user
+      dputs(3){"Found user with groups #{user.groups.inspect} and internet_credit #{user.internet_credit.inspect}"}
+      if Internet.free( user )
+        dputs(3){ 'Found free' }
+        return 'nopay'
+      elsif user.groups and user.groups.index('localonly')
+        dputs(3){ 'Found localonly' }
+        return 'local'
+      elsif user.internet_credit
+        dputs(3){"Credit is #{user.internet_credit.inspect}"}
+        return user.internet_credit
+      end
+    end
+    return 0
+  end
+
+  def self.autoConnect( args, ip )
+    #return "yes"
+    dputs(3){"AutoConnecting for #{args.inspect}"}
+    user = Persons.match_by_login_name( args[:user] )
+    if user 
+      cu = self.clientUse( args, ip )
+      cost_max = Operator.user_cost_max
+      dputs(4){ "clientUse is #{cu.inspect} - cost_max is #{cost_max.inspect}" }
+      case cu
+      when /nopay/
+        return 'yes'
+      when /local/
+        return 'no'
+      when -100...cost_max
+        return 'no'
+      else
+        return 'yes'
+      end
+    end    
+    return 'no'
+  end
+    
+  def self.query( args, ip )
+    dputs(3){"Querying with #{args.inspect}"}
+    case args[:action]
+    when /isAllowed/
+      return self.isAllowed( args, ip )
+    when /login/
+      return self.login( args, ip )
+    when /clientUse/
+      return self.clientUse( args, ip )
+    when /autoConnect/
+      return self.autoConnect( args, ip )
+    end
+  end
+end

data/Paths/Label.rb

@@ -0,0 +1,187 @@
+# This works togehter with UploadMgr to retrieve files.
+require 'erb'
+
+class Label < RPCQooxdooPath
+  @@transfers = {}
+
+  def self.parse_req(req)
+    dputs(4) { "Label: #{req.inspect}" }
+    if req.request_method == 'POST'
+      dputs(0){ 'Deprecated' }
+      exit
+      path, query, addr = req.path, req.query.to_sym, RPCQooxdooHandler.get_ip(req)
+      dputs(4) { "Got query: #{path} - #{query.inspect} - #{addr}" }
+
+      if query._field == 'start'
+        log_msg :label, "Got start-query: #{path} - #{query.inspect} - #{addr}"
+        d = JSON.parse(query._data).to_sym
+        dputs(3) { "d is #{d.inspect}" }
+        if (user = Persons.match_by_login_name(d._user)) and
+            (user.check_pass(d._pass))
+          @@transfers[d._tid] = d.merge(:data => '')
+          return 'OK: send field'
+        else
+          dputs(3) { "User #{d._user.inspect} with pass #{d._pass.inspect} unknown" }
+          return 'Error: authentification'
+        end
+      elsif @@transfers.has_key? query._field
+        tr = @@transfers[query._field]
+        dputs(3) { "Found transfer-id #{query._field}, #{tr._chunks} left" }
+        tr._data += query._data
+        if (tr._chunks -= 1) == 0
+          if Digest::MD5.hexdigest(tr._data) == tr._md5
+            dputs(2) { "Successfully received field #{tr._field}" }
+            ret = self.field_save(tr)
+          else
+            dputs(2) { "Field #{tr._field} transmitted with errors" }
+            ret = 'Error: wrong MD5'
+          end
+          @@transfers.delete query._field
+          return ret
+        else
+          return "OK: send #{tr._chunks} more chunks"
+        end
+      end
+      return 'Error: must start or use existing field'
+    else
+      path = /.*\/([^\/]*)\/([^\/]*)$/.match(req.path)
+      dputs(3) { "Path is #{path.inspect}" }
+      log_msg :label, "Got label-query: #{path.inspect}"
+      self.get_student(path[1], path[2])
+    end
+  end
+
+  def self.get_student(center, grade_id)
+    dputs(3) { "Printing student #{grade_id} of #{center}" }
+    if grade = Grades.match_by_random(grade_id)
+      dputs(3) { "Grade is #{grade.inspect}" }
+      center_short = grade.course.name.sub(/_.*/, '')
+      dputs(3) { "Center_short is #{center_short}" }
+      center = center_short
+      if center_person = Persons.match_by_login_name(center_short)
+        center = center_person.full_name
+      end
+      remark = if grade.remark
+                 if grade.remark =~ /^http:\/\//
+                   "Site web: <a href='#{grade.remark}'>#{grade.remark}</a>"
+                 else
+                   "Remarques: #{grade.remark}"
+                 end
+               else
+                 ''
+               end
+      log_msg :show_grade, "Student #{grade.student.full_name} from #{center} in course #{grade.course.name} " +
+          "has grade #{grade.mean}"
+      if grade.mean >= 10
+        ERB.new(File.open('Files/label.erb') { |f| f.read }).result(binding)
+      else
+        ERB.new(File.open('Files/label_notpassed.erb') { |f| f.read }).result(binding)
+      end
+    else
+      log_msg :show_grade, "Unknown grade-id #{grade_id}"
+      ERB.new(File.open('Files/label_notfound.erb') { |f| f.read }).result(binding)
+    end
+  end
+
+  def self.field_save(tr)
+    dputs(0){ 'Deprecated'}
+    exit
+
+    if not (course_name = tr._course) =~ /^#{tr._user}_/
+      course_name = "#{tr._user}_#{tr._course}"
+    end
+    dputs(3) { "Course-name is #{course_name} and field is #{tr._field}" }
+    case tr._field
+      when 'users'
+        users = JSON.parse(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 = s._permissions & %w( teacher center )
+          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
+        }
+        "OK: Got users #{users.collect { |u| u._login_name }.join(':')}"
+      when 'course'
+        course = JSON.parse(tr._data).to_sym
+        dputs(3) { "Course is #{course.inspect}" }
+        course.delete :course_id
+        course._name = "#{course_name}"
+        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
+        "OK: Updated course #{course._name}"
+      when 'grades'
+        'OK: ' + JSON.parse(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
+        }.to_json
+      when 'exams'
+        tr._tid.gsub!(/[^a-zA-Z0-9_-]/, '')
+        file = "/tmp/#{tr._tid}.zip"
+        File.open(file, 'w') { |f| f.write tr._data }
+        if course = Courses.match_by_name(course_name)
+          dputs(3) { 'Updating exams' }
+          course.zip_read(file)
+        end
+        "OK: Read file #{file}"
+      when 'exams_here'
+        'OK: ' + 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.to_json
+    end
+  end
+end

data/Paths/MobileInfo.rb

@@ -0,0 +1,19 @@
+require 'network'
+require 'helper_classes'
+require 'erb'
+
+
+class MobileInfo < RPCQooxdooPath
+  def self.parse(method, path, query)
+    dputs(3) { "Got #{method} - #{path} - #{query}" }
+    ERB.new(File.open('Files/mobileinfo.erb') { |f| f.read }).result(binding)
+  end
+
+  def self.send_email
+    File.open('/tmp/status.html', 'w') { |f|
+      f.write(ERB.new(File.open('Files/mobileinfo.erb') { |f| f.read }).result(binding))
+    }
+    System.run_bool('echo ".-=-." | mail -a /tmp/status.html -s "$( hostname ): Connected" root@localhost')
+    log_msg :MobileInfo, 'Sent e-mail'
+  end
+end

data/Paths/internetCash.rb

@@ -0,0 +1,34 @@
+
+
+class InternetCash < RPCQooxdooPath
+  def self.parse_req_res(req, res)
+    ip = RPCQooxdooHandler.get_ip( req )
+    query = req.query
+    dputs(4) { "InternetCash: #{req.inspect} - #{req.path} - #{ip}" }
+    if req.request_method == 'GET'
+      case req.path
+        when /fetch_users/
+          user_list = []
+          Persons.search_all.each { |p|
+            credit = 0
+            if p.internet_credit.to_i > 0
+              credit = p.internet_credit.to_i
+              p.internet_credit = 0
+            end
+            free = Permission.can_view(p.permissions, 'FlagInternetFree') or
+                Internet.active_course_for(p)
+            if free or credit > 0
+              dputs(3) { "Putting #{p.login_name} with credit #{credit} - #{free.inspect}" }
+              user_list.push [p.login_name, p.password, credit, free]
+            end
+          }
+          return user_list.to_json
+        when /update_connection/
+          return Internet.update_connection( ip, query._user )
+        else
+          dputs(0) { "Error: #{req.inspect} is not supported" }
+      end
+    end
+  end
+end
+

data/Paths/internetWifi.rb

@@ -0,0 +1,54 @@
+class InternetWifi < RPCQooxdooPath
+  def self.parse_req_res(req, res)
+    ip = RPCQooxdooHandler.get_ip(req)
+    path, query = req.path, req.query
+    dputs(4) { "InternetWifi: #{req.inspect} - #{req.path} - #{ip}" }
+    if req.request_method == 'GET'
+      case path
+        when /users.cgi/
+          return 'mac'
+        when /connect.cgi/
+          login_name, password = query._user, query._pass
+          person = Persons.match_by_login_name(login_name)
+          person and dputs(3) { "Person is #{person.inspect} and #{person.password}" }
+          if person and person.check_pass(password) then
+            session = Sessions.create(person)
+            session.web_req = req
+            session.client_ip = RPCQooxdooHandler.get_ip(req)
+            dputs(3) { "Found login #{person.data_get(:person_id)} for #{login_name}" }
+            dputs(3) { "Session is #{session.inspect}" }
+            log_msg :InternetWifi, "Authenticated person #{person.login_name} from " +
+                                     "#{session.client_ip} and redirecting"
+          end
+          addr = 'admin.profeda.org'
+          #addr = 'localhost:3302'
+          return self.redirect(addr)
+        when /favicon.ico/
+          return ''
+        when /internetwifi/
+          return self.redirect('http://admin.profeda.org')
+        else
+          dputs(0) { "Error: #{path} in #{req.inspect} is not supported" }
+      end
+    end
+  end
+
+  def self.redirect(address, timeout=0)
+    "
+<!DOCTYPE HTML>
+<html lang='fr-FR'>
+    <head>
+        <meta charset='UTF-8'>
+        <meta http-equiv='refresh' content='#{timeout};url=#{address}'>
+        <script type='text/javascript'>
+            window.location.href = '#{address}'
+        </script>
+        <title>Page Redirection</title>
+    </head>
+    <body>
+        If you are not redirected automatically, follow the <a href='#{address}'>link to example</a>
+    </body>
+</html>"
+  end
+end
+

data/README.md

@@ -0,0 +1,60 @@
+# Gestion
+
+Allows for handling of day-to-day tasks in a small school, think cultural center
+that offers classes.
+
+## Functions
+
+For the cultural center-part, the following functions are implemented:
+
+  * Rights management (for students, secretary, director, admin, ...)
+  * Creation of courses (using templates for different courses)
+    * Sign up of students to courses
+    * Entering grades of students
+    * Creating diplomas
+  * Accounting
+    * Payments of students
+    * Internet-usage
+    * Other, simple 2-way accounting
+
+There is also a network-part which has the following functions:
+
+  * Sharing with samba (public, read and read-write access)
+  * Internet-gateway using usb-modems or Ethernet-port
+  * Access-control of students when installed as captive gateway
+  * Controlling internet-credit, works for now only for Chad
+
+## Hardware
+
+It has been tested on ArchLinux running on different ARM-boxes (Dreamplug,
+Smileplug and Cubox-i). Most of the parts also run on Ubuntu.
+
+## Software
+
+The user-interface is using http://QooxDoo.org with a ruby-back-end called
+QooxView. Different libraries are used:
+
+  * AfriCompta - simple accounting program for QooxView
+  * HelperClasses - some modules to make life easier
+  * HilinkModem - interface for the infamous hilinkmodems which lack USSD-support!
+  * Network - captive interface and usb-modems definition
+  * QooxView - RPC backend for QooxDoo, also implementing a simple ActiveRecord
+    backend with CSV-files
+  * SerialModem - interface for simple ttyUSB-modems
+
+## Installation
+
+Unfortunately there is no gem-package available as yet. But a pacman-version exists 
+that you can download under http://github.com/ineiti/Gestion/releases/latest
+
+If you're adventurous, you can try the following:
+
+```
+for s in AfriCompta Gestion HelperClasses HilinkModem Network QooxView SerialModem; do
+  git clone https://github.com/ineiti/$s
+done
+cd Gestion
+./Gestion
+```
+
+Which 'should work' (tm).

data/Rakefile

@@ -0,0 +1,13 @@
+def gemf(ext = '')
+  puts `pwd`
+  puts `bundle config --local gemfile Gemfile#{ext}`
+  puts `bundle install`
+end
+
+task :default do
+  gemf
+end
+
+task :dev do
+  gemf( '.dev' )
+end