gestion 1.9.12

data/Entities/Plug.rb

@@ -0,0 +1,98 @@
+class Plugs < Entities
+  def setup_data
+    value_str :internal_id
+    value_str :fixed_id
+    value_str :center_name
+    value_str :center_id
+    value_str :center_city
+    value_str :ip_local
+    value_date :installation
+    value_str :telephone
+    value_str :credit
+    value_str :internet_left
+    value_list_drop :model, '%w(DreamPlug08 DreamPlug10 Smileplug
+      Cubox-i1 Cubox-i2x Cubox-i4)'
+    value_int :storage_size
+
+    Network::Device.add_observer(self)
+    update('add', Network::Device.search_dev({uevent: {driver: 'option'}}).first)
+  end
+
+  def update(op, dev = nil)
+    return unless ConfigBase.has_function?(:plug_admin)
+    dputs(2) { "Updating with operation #{op} and device #{dev}" }
+    if op =~ /add/ && dev && dev.instance_variable_defined?(:@serial_sms_new)
+      dev.serial_sms_new.push(Proc.new { |sms| new_sms(sms) })
+    end
+  end
+
+  def new_sms(sms)
+    dputs_func
+    dputs(2) { "Found new sms #{sms.inspect}" }
+    search_all_.each { |p|
+      # Match for incomplete, but existing telephone number. Make sure that
+      # +235999999 matches 999999, in both ways
+      p1 = p.telephone.to_s.gsub(/[^0-9]/, '')
+      p2 = sms._number.gsub(/[^0-9]/, '')
+      dputs(3) { "Phone-numbers are _#{p1}_ and _#{p2}_" }
+      if p1.length > 0 && (p1 =~ /#{p2}$/ || p2 =~ /#{p1}$/)
+        p.new_sms(sms)
+      end
+    }
+  end
+
+  def listp_center
+    Plugs.search_all_.collect{|p| [p.plug_id, p.center_name]}
+  end
+end
+
+class Plug < Entity
+  def send_cmd_sms(*cmds)
+    return unless telephone.to_s.length > 0 &&
+        !$MobileControl.operator_missing?
+    msg = "cmd: #{cmds.join('::')}"
+    add_stat(msg, :sms, :send)
+    $MobileControl.device.sms_send(telephone.to_s, msg)
+  end
+
+  def send_credit(amount)
+    return unless telephone.to_s.length > 0 &&
+        !$MobileControl.operator_missing?
+    add_stat(amount.to_s, :credit, :send)
+    $MobileControl.operator.credit_send(telephone.to_s, amount)
+  end
+
+  def new_sms(sms)
+    add_stat(sms._msg, :sms, :rcv)
+    log_msg :Plug, "Got new sms #{sms.inspect}"
+    case sms._msg
+      when /^stat: (.*): (.*) :: (.*) :: (.*)/
+        host, state, disk, time = $1, $2, $3, $4
+        _, _, _, internet, credit = state.split(':')
+        dputs(2) { "Host #{host} has state #{state}" }
+        self.internal_id = host
+        if internet != 'noop'
+          self.internet_left = internet.gsub(/[^0-9]/, '').to_i * 1_000_000
+          self.credit = credit
+          dputs(2) { "Host #{host} has #{internet} Bytes and #{self.credit} left" }
+        end
+      else
+        log_msg :Plut, "Unknown message from #{host}"
+    end
+  end
+
+  def add_stat(msg, type, dir)
+    PlugStats.create(time: Time.now, msg: msg, msg_type: [type],
+                     msg_dir: [dir], plug: self)
+  end
+end
+
+class PlugStats < Entities
+  def setup_data
+    value_time :time
+    value_str :msg
+    value_list :msg_type, '%w( sms email rpc credit )'
+    value_list :msg_dir, '%w( send rcv )'
+    value_entity :plug
+  end
+end

data/Entities/Quiz.rb

@@ -0,0 +1,33 @@
+class Quizs < Entities
+  def setup_data
+    value_str :email
+    value_str :full_name
+    value_str :reply
+    value_int :score
+  end
+
+  def create( a )
+    dputs( 4 ){ "Creating Quiz with #{a.inspect}" }
+    q = super( a )
+    q.score = q.evaluate
+    q
+  end
+
+  def self.results
+    self.search_all.collect{|q| [ q.score, q.full_name ] }.
+      sort{ |a,b| b[0] <=> a[0] }.collect{|q| q.join( ":" ) }
+  end
+end
+
+class Quiz < Entity
+  def evaluate
+    correct = %w( 1992 2007 faux route fai faux faux courriel www faux recherche ouvert
+      90 55000 ICANN IANA IAB NTIC isoc-chad.org )
+    s = 0
+    reply.split(",")[0..-2].each{|r|
+      r.to_s == correct.shift.to_s and s += 1
+    }
+    s
+  end
+
+end

data/Entities/Recharges.rb

@@ -0,0 +1,37 @@
+class Recharges < Entities
+  def setup_data
+    value_str :time
+    value_int :volume
+    value_int :days_valid
+    value_int :days_goal
+  end
+
+  def enabled?
+    search_all_.length > 0
+  end
+end
+
+class Recharge < Entity
+  def left_today(left_total)
+    return -1 if days_goal.to_i <= 0
+    end_of_day = (days_goal.to_i - (Date.today - day) - 1) * volume.to_i / days_goal.to_i
+    (left_total - (end_of_day < 0 ? 0 : end_of_day)).to_i
+  end
+
+  def day
+    begin
+      year, month, day = time.scan(/../)
+      Date.new(2000 + year.to_i, month.to_i, day.to_i)
+    rescue ArgumentError => e
+      Date.today
+    end
+  end
+
+  def self.left_today(left_total)
+    if (r = Recharges.search_all_).length > 0
+      r.sort { |a, b| a.time <=> b.time }.last.left_today(left_total)
+    else
+      -1
+    end
+  end
+end

data/Entities/Report.rb

@@ -0,0 +1,136 @@
+class ReportAccounts < Entities
+  def setup_data
+    value_entity_account :root, :drop, :path
+    value_entity_account :account, :drop, :path
+    value_int :level
+  end
+end
+
+
+class Reports < Entities
+  def setup_data
+    value_str :name
+    value_list_entity_reportAccounts :accounts
+  end
+end
+
+class Report < Entity
+  attr_accessor :print_accounts, :print_movements, :print_account
+
+  def print_account_monthly(acc, start, months, counter)
+    stop = (start >> months) - 1
+
+    line = []
+    zeros = false
+    @print_account = ''
+    @print_accounts = counter.to_f / accounts.count
+    p_a = 0
+    acc.account.get_tree(acc.level.to_i) { |acc_sub, depth|
+      acc_sub.get_tree(depth > 0 ? 0 : -1) { p_a += accounts.count }
+    }
+    acc.account.get_tree(acc.level.to_i) { |acc_sub, depth|
+      dputs(2) { "Doing #{acc_sub.path} - #{depth.inspect}. Done: #{@print_accounts}" }
+      sum = Array.new(months) { 0 }
+      acc_sub.get_tree(depth > 0 ? 0 : -1) { |acc_sum|
+        @print_account = acc_sum.get_path
+        @print_accounts += 1.0 / p_a
+        p_m = 1.0 / acc_sum.movements.count
+        @print_movements = 0
+        acc_sum.movements.each { |m|
+          @print_movements += p_m
+          if (start..stop).include? m.date
+            sum[m.date.month - start.month] += m.get_value(acc_sum)
+          end
+        }
+      }
+      if sum.inject(false) { |m, o| m |= o != 0 } or line.size == 0
+        if line.size == 0
+          zeros = true
+        elsif zeros
+          line = []
+          zeros = false
+        end
+        line.push [acc_sub.path, sum + [sum.inject(:+)]]
+      end
+    }
+    line
+  end
+
+  def print_heading_monthly(start = Date.today, months = 12)
+    ['Period', (0...months).collect { |m|
+               (start >> m).strftime('%Y/%m')
+             } + ['Sum']]
+  end
+
+  def print_list_monthly(start = Date.today, months = 12)
+    stop = start >> (months - 1)
+    acc_counter = -1
+    list = accounts.collect { |acc|
+      line = print_account_monthly(acc, start, months, acc_counter += 1)
+      if line.size > 1
+        line.push ['Sum', line.reduce(Array.new(months+1, 0)) { |memo, obj|
+                          dputs(2) { "#{memo}, #{obj.inspect}" }
+                          memo = memo.zip(obj[1]).map { |a, b| a + b }
+                        }]
+      end
+      line
+    }
+    if list.size > 1
+      list + [[['Total', running = list.reduce(Array.new(months+1, 0)) { |memo, obj|
+                         dputs(2) { "#{memo}, #{obj.inspect}" }
+                         memo = memo.zip(obj.last.last).map { |a, b| a + b }
+                       }],
+               ['Running', running[0..-2].reduce([]) { |m, o| m + [(m.last || 0) + o] }]]]
+    else
+      list
+    end
+  end
+
+  def print(start = Date.today, months = 12)
+
+  end
+
+  def listp_accounts
+    accounts.collect { |a|
+      [a.id, "#{a.level}: #{a.account.path}"]
+    }
+  end
+
+  def print_pdf_monthly(start = Date.today, months = 12)
+    stop = start >> (months - 1)
+    file = "/tmp/report_#{name}.pdf"
+    Prawn::Document.generate(file,
+                             :page_size => 'A4',
+                             :page_layout => :landscape,
+                             :bottom_margin => 2.cm) do |pdf|
+
+      pdf.text "Report for #{name}",
+               :align => :center, :size => 20
+      pdf.font_size 7
+      pdf.text "From #{start.strftime('%Y/%m')} to #{stop.strftime('%Y/%m')}"
+      pdf.move_down 1.cm
+
+      pdf.table([print_heading_monthly(start, months).flatten.collect { |ch|
+                   {:content => ch, :align => :center} }] +
+                    print_list_monthly(start, months).collect { |acc|
+                      acc.collect { |a, values|
+                        [a] + values.collect { |v| Account.total_form(v) }
+                      }
+                    }.flatten(1).collect { |line|
+                      a, s = (line[0] =~ /::/ ? [:left, :normal] : [:right, :bold])
+                      [{:content => line.shift, :align => a, :font_style => s}] +
+                          line.collect { |v|
+                            {:content => v, :align => :right, :font_style => s} }
+                    },
+                :header => true)
+      pdf.move_down(2.cm)
+
+      pdf.repeat(:all, :dynamic => true) do
+        pdf.draw_text "#{Date.today} - #{name}",
+                      :at => [0, -20], :size => 10
+        pdf.draw_text pdf.page_number, :at => [18.cm, -20]
+      end
+    end
+    file
+  end
+end

data/Entities/Room.rb

@@ -0,0 +1,12 @@
+# Represents the different rooms available in the facility
+
+class Rooms < Entities
+  def setup_data
+    value_block :all
+    value_str :name
+    value_int :size
+    value_str :ip_net
+    value_int :computers
+    value_str :description
+  end
+end

data/Entities/SMS.rb

@@ -0,0 +1,30 @@
+# Holds SMS from Modem
+
+class SMSs < Entities
+  def setup_data
+    value_date :date
+    value_phone :phone
+    value_txt :text
+    value_int :index
+  end
+
+  def last(count)
+    return [] if @data.length == 0 || count <= 0
+
+    msgs = [count, @data.length].min
+    dputs(3) { "Getting #{msgs} SMS for #{@data.inspect}" }
+    @data.keys.sort[-msgs..-1].collect { |d|
+      get_data_instance(d)
+    }
+  end
+
+  def create(sms)
+    if !match_by_date(sms._date)
+      super({date: sms._date, phone: sms._number, text: sms._msg,
+             index: sms._id})
+    end
+    while @data.length > 50
+      get_data_instance(@data.first.first).delete
+    end
+  end
+end

data/Entities/ScheduleType.rb

@@ -0,0 +1,33 @@
+class ScheduleTypes < Entities
+  def setup_data
+    value_str :name
+    value_str :schedule
+  end
+
+  def self.get_script
+    return IO.read('Files/timetable.js')
+  end
+
+  def self.get_html(weeks: false)
+    return "<style type='text/css'>
+        td.select {
+            background-color: #00ffff
+        }</style>
+    <table width='80%' border=0 onload='add_weeks(16); add_days();add_hours();'> " +
+        (weeks ? "<tr id='tr_weeks'></tr>" : '') +
+        "<tr id='tr_days'></tr>
+      <tr id='tr_programs'></ tr>
+    <tr id='tr_hours'></tr>
+    </ table>"
+  end
+end
+
+class ScheduleType < Entity
+  def schedule_array
+    JSON.parse(schedule)
+  end
+
+  def schedule_array=(s)
+    schedule = s.to_json
+  end
+end

data/Entities/Share.rb

@@ -0,0 +1,120 @@
+# Holds share for samba
+
+class Shares < Entities
+  def setup_data
+    value_block :config
+    value_str :name
+    value_str :path
+    value_str :comment
+    value_str :force_user
+    value_str :force_group
+    #value_text :args
+    value_list_drop :public, '%w( No Read ReadWrite )'
+
+    value_block :acl
+    value_str :acl
+  end
+
+  def migration_1(s)
+    s.public = [s.public.first == 'Yes' ? 'ReadWrite' : 'No']
+  end
+
+  def save_config(domain)
+    dputs_func
+    return unless Shares.is_active?
+
+    a = IO.read('Files/smb.conf')
+    a.gsub!(/WORKGROUP/, domain)
+    a.gsub!(/SERVER/, "Profeda-server on #{domain}")
+    a += "\n"
+    Shares.search_all_.each { |sh|
+      if !Dir.exists?(sh.path)
+        FileUtils.mkdir_p(sh.path)
+      end
+      begin
+        FileUtils.chmod 0777, sh.path
+      rescue Errno::EROFS => e
+        log_msg :Share, "Oups, couldn't chmod #{e.inspect}"
+      end
+      a += "\n\n[#{sh.name}]\n  path = #{sh.path}\n  comment = #{sh.comment}\n"
+      valid_users = []
+      if sh.force_user.to_s.length > 0
+        a += "  force user = #{sh.force_user}\n"
+        valid_users.push sh.force_user
+      end
+      if sh.force_group.to_s.length > 0
+        a += "  force group = #{sh.force_group}\n"
+        valid_users.push sh.force_group
+      end
+      case sh.public.first
+        when 'Read'
+          a += "  guest ok = yes\n  writeable = no\n"
+        when 'ReadWrite'
+          a += "  guest ok = yes\n  writeable = yes\n"
+        else
+          read = []
+          write = []
+          dputs(4) { "sh is #{sh.class}" }
+          sh.acl.class == Hash and sh.acl.each { |k, v|
+            dputs(4) { "Found #{k}: #{v}" }
+            case v
+              when /rw/
+                write.push k
+              when /ro/
+                read.push k
+            end
+          }
+          a += "  read list = #{read.join(',')}\n  write list = #{write.join(',')}\n" +
+              "  valid users = #{ (read + write + valid_users).uniq.join(',')}\n"
+      end
+      a += "  directory mask = 0775\n  create mask = 0664\n"
+      #a += "  hide files = /~$*/*.tmp/\n   blocking locks = no\n"
+      #a += "  create mask = 741\n  map archive = yes\n  map system = yes\n" +
+      #  "  map hidden = yes\n"
+    }
+    file_smb = "#{ConfigBase.samba_config}/smb.conf"
+    File.open(file_smb, 'w') { |f|
+      f.write(a)
+    }
+
+    Platform.restart('samba')
+  end
+
+  def self.is_active?
+    ConfigBase.samba_simul == %w(false) &&
+        !get_config(false, :Entities, :Share, :simulation)
+  end
+end
+
+class Share < Entity
+  def setup_instance
+    if not self.acl
+      self.acl = {}
+    end
+  end
+
+  def add_htaccess
+    if File.exists? path
+      File.open("#{path}/.htaccess", "w") { |f|
+        f << "AuthType Basic
+AuthName 'Restricted Access'
+AuthUserFile '#{path}/.htpasswd'
+Require valid-user
+"
+      }
+      File.exists? passfile = "#{path}/.htpasswd" and
+          FileUtils.rm passfile
+      if acl.class == Hash
+        acl.each { |k, v|
+          dputs(4) { "Adding #{k} to htpasswd" }
+          case v
+            when /rw|ro/
+              dputs(4) { "Really adding #{k} to #{passfile}" }
+              user = Persons.find_by_login_name(k)
+              System.run_str("/usr/bin/htpasswd -bnd #{user.login_name} '#{user.password_plain }' >> #{passfile}")
+          end
+        }
+      end
+    end
+  end
+end

data/Entities/Task.rb

@@ -0,0 +1,51 @@
+class Tasks < Entities
+  def setup_data
+    value_str :date_name
+    
+    value_block :who
+    value_str :client
+    value_str :person
+    value_entity_person :worker, :drop, :full_name
+    
+    value_block :work
+    value_date :date
+    value_list_drop :time, "22.times.collect{|t| sprintf( '%02i.%02i', 7 + ( t / 2 ).floor, 30 * ( t % 2 ) )}"
+    value_int :duration_hours
+    value_text :work
+    
+    value_block :other
+    value_int :transport_length
+    value_list_single :transport_type, "%w( moto voiture taxi )"
+    value_int :cost
+    value_str :cost_description
+    value_int :gain
+    value_str :gain_description
+  end
+
+  def data_to_time( d )
+    dputs( 3 ){ d.inspect }
+    t = d[:date].split('.').values_at( 2, 1, 0 ) +
+        d[:time].to_s.split('.')
+    Time.utc( *t )
+  end
+
+  def listp_tasks
+    @data.values.sort{|a,b|
+        data_to_time(a) <=> data_to_time(b)
+        }.reverse.collect{ |d|
+      [ d[:task_id], data_to_time(d).strftime("%d.%m.%y") + " - " + d[:person].to_s]
+      }
+  end
+  
+  def list_task_month( worker, year, month, client )
+    @data.values.select{|d|
+      dputs( 3 ){ "Data is: #{d.inspect}" }
+      date = data_to_time( d )
+      dputs( 3 ){ [ date.inspect, year, month, worker, d[:person] ].inspect }
+      date.year == year.to_i and 
+        date.month == month.to_i and 
+        worker == Entities.Workers.find_full_name( d[:person][0] ) and
+        client.name == d[:client][0]
+    }
+  end
+end

data/Entities/Ticket.rb

@@ -0,0 +1,72 @@
+# A ticket is opened for computers only
+
+class Tickets < Entities
+  def setup_data
+    value_block :date
+    value_date :opened
+    value_date :closed
+    value_list_drop :severity, "%w( critique grave moyen optionnel )"
+    value_str_ro :created_by
+    value_entity_person_empty :assigned, :drop, :full_name,
+      lambda{|p| p.permissions.index("maintenance")}
+    value_entity_computer_empty :computer, :drop, :name_service
+    value_str :other
+    
+    value_block :detail
+    value_text :todo
+    value_text :verification
+    value_text :work
+  end
+  
+  def listp_opened( closed = false )
+    search_all.select{|k|
+      ( not k.closed ) ^ closed
+    }.collect{|k|
+      dputs( 4 ){ "k is #{k.inspect}" }
+      comp = k.computer != 0 ? k.computer.name_service : "---"
+      [k.ticket_id, "#{k.opened} - #{comp}" ] 
+    }.sort{|a,b|
+      a[1] <=> b[1]
+    }.reverse
+  end
+  
+  def listp_closed
+    listp_opened( true )
+  end
+  
+end
+
+module TicketLayout
+  def t_layout( method )
+    set_data_class :Tickets
+    @update = true
+    @order = method == :opened ? 150 : 200
+    
+    gui_hbox do
+      gui_vbox :nogroup do
+        vtlp_list :ticket_list, method, :width => 150
+        if method == :opened
+          show_button :new_ticket, :delete
+        else
+          show_button :delete
+        end
+      end
+
+      gui_vbox :nogroup do
+        gui_hbox :nogroup do
+          gui_vbox :nogroup do
+            show_block :date
+          end
+          gui_vbox :nogroup do
+            show_block :detail, :width => 150
+          end
+        end
+        if method == :opened
+          show_button :save_ticket
+        else
+          show_button :save
+        end
+      end
+    end
+  end
+end