gestion 1.9.12

data/Entities/CourseType.rb

@@ -0,0 +1,171 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+class CourseTypes < Entities
+  def setup_data
+    value_str :file_diploma
+    value_str :file_exam
+
+    value_block :strings
+    value_str :name
+    value_str :duration
+
+    value_block :long
+    value_str :description
+    value_text :contents
+
+    value_block :central
+    value_list_drop :diploma_type, '%w( simple files accredited report )'
+    value_list_drop :output, '%w( certificate label )'
+    value_list_drop :diploma_lang, '%w( en fr )'
+    value_list_drop :page_format,
+                    "[[1,'normal'],[2,'interchanged'],[3,'landscape'],[4,'seascape']]"
+    value_list_drop :remark, '%w(false true)'
+
+    value_block :lists
+    value_str :tests_str
+    value_int :tests_nbr
+    value_str :files_str
+    value_int :files_nbr
+
+    value_block :accounting
+    value_int :salary_teacher
+    value_int :cost_student
+
+    value_block :account
+    value_entity_account :account_base, :drop, :path
+  end
+
+  def self.files
+    ddir = Courses.dir_diplomas
+    Dir.glob(ddir + '/*{odt,odg,ods}').
+        collect { |f| f.sub(/^.*\//, '') }
+  end
+
+  def set_entry(id, field, value)
+    case field.to_s
+      when 'name'
+        value.gsub!(/[^a-zA-Z0-9_-]/, '_')
+    end
+    super(id, field, value)
+  end
+
+  def listp_name
+    CourseTypes.listp_name
+  end
+
+  def self.listp_name
+    self.search_all_.collect { |ct|
+      [ct.coursetype_id, ct.name]
+    }.sort { |a, b| a[1].downcase <=> b[1].downcase }
+  end
+
+  def migration_1(ct)
+    ct.tests = 1
+    ct.output = ['certificate']
+  end
+
+  def migration_2(ct)
+    ct.diploma_type = ['simple']
+  end
+
+  def migration_3(ct)
+    ct.page_format = [0]
+  end
+
+  def migration_4(ct)
+    ct.page_format[0] += 1
+  end
+
+  # Changed tests to tests_str and files_needed to files_str
+  def migration_5_raw(ct)
+    if (ct._tests_nbr = ct._tests.to_i) > 0
+      ct._tests_str = (1..ct._tests_nbr).collect { |t| "Test #{t}" }.join("\n")
+    end
+    if (ct._files_nbr = ct._files_needed.to_i) > 0
+      ct._files_str = (1..ct._files_nbr).collect { |f| "Files #{f}" }.join("\n")
+    end
+  end
+
+  def migration_6(ct)
+    ct.diploma_lang = ['fr']
+  end
+
+  def icc_list(arg)
+    list_name
+  end
+
+  def icc_fetch(arg)
+    if ct_names = arg._course_type_names
+      ct_names.collect { |ct|
+        self.find_by_name(ct) or return "Error: CourseType #{ct} doesn't exist"
+      }
+    else
+      return 'Error: no course_type_name given'
+    end
+  end
+
+  def icc_file(arg)
+    file = "#{ConfigBase.template_dir}/#{File.basename(arg._name.first)}"
+    if File.exists? file
+      log_msg :CourseTypes, "Sending file #{file}"
+      IO.binread(file)
+    else
+      log_msg :CourseTypes, "Didn't find #{file.inspect}"
+      return "Error: can't find file"
+    end
+  end
+end
+
+class CourseType < Entity
+  def setup_instance
+    self.diploma_lang ||= ['fr']
+    self.files_nbr ||= 0
+  end
+
+  def get_unique
+    name
+  end
+
+  def clean_str(str)
+    s = str.to_s.split("\n").
+        collect { |s| s.sub(/^\s*/, '').sub(/\s*$/, '') }.
+        select { |s| s.length > 0 }
+    [s.join("\n"), s.length]
+  end
+
+  def tests_str=(str)
+    self._tests_str, self.tests_nbr = clean_str(str)
+  end
+
+  def tests_arr
+    tests_str.to_s.split("\n")
+  end
+
+  def files_str=(str)
+    self._files_str, self.files_nbr = clean_str(str)
+  end
+
+  def files_arr
+    files_str.to_s.split("\n")
+  end
+
+  def delete
+    if Courses.search_by_ctype(self).size > 0
+      log_msg :CourseType, "Tried to delete #{self.name} while courses still depend on it"
+      return false
+    else
+      super
+      return true
+    end
+  end
+
+  def file_diploma=(f)
+    return if @loading
+    self._file_diploma = f
+    Courses.search_by_ctype(self).each{|c|
+      c.update_exam_file
+    }
+    f
+  end
+end

data/Entities/DFiles.rb

@@ -0,0 +1,466 @@
+# DFiles is used to manage the updating of the files-repository on the
+# Profeda-installations.
+# - sync with a harddisk or over ssh
+# - update the file-tree
+
+class DFiles < Entities
+  attr_accessor :dir_base, :dir_files, :dir_descs, :url_html
+
+  def setup_data
+    value_int :dfile_id
+    value_str :name
+    value_str :desc_file
+    # url_file holds the url to the file. It can be preceded
+    # by a name held between two ":", which will be the
+    # save_file-name. Else the save_file-name is the 'basename' of the
+    # url_file
+    value_str :url_file
+    value_str :save_file
+    value_str :url_page
+    value_str :desc
+    # os and category are used to build the dokuwiki-pages
+    value_str :os
+    value_str :category
+    # tags are additional fields
+    value_str :tags
+    value_int :file_size
+
+    # Only used once a DFile is found - will not be stored, but represents
+    # the priority that will be used for pruning.
+    value_int :priority
+
+    set_dir_base('/opt/Files')
+  end
+
+  def set_dir_base(dir)
+    @dir_base = dir
+    @dir_files = File.join(@dir_base, 'files')
+    @dir_descs = File.join(@dir_base, 'descs')
+    @dir_html = File.join(@dir_base, 'html')
+    @url_html = 'http://files.ndjair.net/'
+  end
+
+  # searches for all descriptions in @dir_descs
+  def load(has_static = true)
+    #dputs_func
+    delete_all(true)
+    dputs(2) { "Loading descs from #{@dir_descs}" }
+    if Dir.exists?(@dir_descs)
+      dputs(4) { 'Directory exists' }
+      file_id = 1
+      Dir.glob("#{@dir_descs}/*.desc").each { |f|
+        dputs(4) { "Working on file #{f}" }
+        name = File.basename(f)
+        lines = IO.readlines(f).collect { |l| l.chomp }
+        if lines.size >= 7
+          file = {
+              dfile_id: file_id,
+              desc_file: name,
+              name: name.sub(/.desc$/, ''),
+              url_file: lines[0],
+              url_page: lines[1],
+              desc: lines[3],
+              os: lines[5],
+              category: lines[6],
+              tags: lines[5..-1].collect { |t|
+                t.split(' ')
+              }
+          }
+          if file[:url_file][0] == ':'
+            su = file[:url_file].match(/^:([^:]*):(.*)$/)
+            file[:save_file] = su[1]
+            file[:url_file] = su[2]
+          else
+            file[:save_file] = File.basename(file[:url_file])
+          end
+          dputs(3) { "Saving description #{file}" }
+          file_path = File.join(@dir_files, file[:save_file])
+          file[:file_size] = File.exists?(file_path) ? File.size(file_path) : 0
+          @data[file_id] = file
+          file_id += 1
+        else
+          dputs(2) { "Description #{f} has not enough lines, skipping" }
+        end
+      }
+    else
+      dputs(2) { "Didn't find directory #{@dir_descs}" }
+    end
+    dputs(3) { @data.inspect }
+  end
+
+  # saves back the descriptions to @dir_descs
+  def save()
+    return unless @changed
+    if Dir.exists?(@dir_descs)
+      FileUtils.rm(Dir.glob("#{@dir_descs}/*.desc"))
+    else
+      FileUtils.mkpath(@dir_descs)
+    end
+    @data.each { |k, v|
+      File.open("#{@dir_descs}/#{v[:desc_file]}", 'w') { |f|
+        if (file = v[:save_file]) != File.basename(v[:url_file])
+          v[:url_file] = ":#{file}:#{v[:url_file]}"
+        end
+
+        f.puts(v[:url_file], v[:url_page], '',
+               v[:desc], '',
+               v[:os], v[:category])
+        v[:tags].each { |t| f.puts(t.join(' ')) }
+      }
+    }
+  end
+
+  # updates the descriptions from a directory (probably a mount-point, has to
+  # be mounted before)
+  def update_desc_from_dir(update_dir)
+    return unless Dir.exists?(update_dir)
+    Dir.glob(File.join(update_dir, '*.desc')).each { |f|
+      name = File.basename(f)
+      local_name = File.join(@dir_descs, name)
+      if File.size(f) == 0
+        # This is a file that has to be removed
+        File.rm(local_name)
+      else
+        dputs(3) { "Copying #{f} to #{local_name}" }
+        FileUtils.cp(f, local_name)
+      end
+    }
+    load
+  end
+
+  # copies the files from a directory to @dir_files
+  def update_files_from_dir(update_dir)
+    #dputs_func
+    load
+    unless Dir.exists? @dir_files
+      FileUtils.mkpath @dir_files
+    end
+    # Update all sizes, delete if file is missing
+    search_all_.each { |df|
+      df.file_size = 0
+      [@dir_files, update_dir].each { |d|
+        file = File.join(d, df.save_file)
+        if File.exists?(file)
+          df.file_size = File.size(file)
+          dputs(3) { "Found file #{file} with size #{df.file_size}" }
+        else
+          df.file_size = 0
+        end
+      }
+      if df.file_size == 0
+        df.delete
+      end
+    }
+
+    files_wanted = get_limited_files(DFilePriorities.get_most_wanted,
+                                     DFileConfig.limit_size * 2**30).
+        collect { |f| f.save_file }
+    files_here = Dir.glob(File.join(@dir_files, '/*')).
+        collect { |f| File.basename(f) }
+    files_delete = files_here - files_wanted
+    files_copy = files_wanted - files_here
+    dputs(3) { "Files to delete are: #{files_delete}" }
+    dputs(3) { "Files to copy are: #{files_delete}" }
+
+    # Delete not used files
+    files_delete.each { |f|
+      file = File.join(@dir_files, f)
+      dputs(3) { "Deleting file #{file}" }
+      FileUtils.rm(file)
+    }
+
+    # Copy new files
+    files_copy.each { |f|
+      file = File.join(update_dir, f)
+      dputs(3) { "Copying file #{file}" }
+      FileUtils.cp(file, @dir_files)
+    }
+    save
+  end
+
+  # Returns the first files so that the total is not above the
+  # size_limit
+  def get_limited_files(files, size_limit)
+    ret = files.dup
+    if size_limit > 0
+      # Prioritize the files
+      while ret.inject(0) { |tot, f| tot + f.file_size } > size_limit
+        # We have too many files and need to prune some entries
+        ret.delete(ret.last)
+      end
+    end
+    ret
+  end
+
+  def get_size(dir, files)
+    files.inject(0) { |tot, file|
+      tot += File.size(dir + "/#{file}")
+    }
+  end
+
+  # get_tags returns all tags with the most common tags at the beginning
+  def get_tags(tag)
+    # Get a list of all tags wihtout the priority
+    tags = search_by_tags(tag).collect { |df| df.tags.collect { |_, t| t } }.flatten.sort
+    # Count how many times each tag appears and sort inversely
+    tags_count = tags.uniq.collect { |t| [tags.count(t), t] }.sort { |a, b| b[0] <=> a[0] }
+    # Remove the counter
+    tags_count.collect { |_, t| t }
+  end
+
+  # creates html-files for downloading the files
+  def update_html
+    used_tags = %w(windows mac linux android media).select { |tag|
+      get_tags(tag).size > 0 }
+
+    # First create index.html
+    save_html('index.html',
+              "<ul>\n" +
+                  used_tags.collect { |tag|
+                    "<li><a href='#{@url_html}/html/#{tag}_all.html'>#{tag.capitalize}</a>"
+                  }.join("\n") +
+                  "</ul>\n")
+
+    unless File.exists?(@dir_html)
+      FileUtils.mkdir(@dir_html)
+    end
+    # Add each main tag that exists
+    used_tags.each { |tag|
+      save_html(File.join('html', "#{tag}_all.html"),
+                "<h1>#{tag.capitalize}</h1>\n" +
+                    html_tag_links(tag) +
+                    "<h3><a href='../index.html'>Home</a></h3>" +
+                    html_tag_files(tag)
+      )
+      # Add tag-files
+      (get_tags(tag) - [tag]).each { |t|
+        save_html(File.join('html', "#{tag}_#{t}.html"),
+                  "<h1><a href='#{tag}_all.html'>#{tag.capitalize}</a></h1>\n" +
+                  "<h2 class='subtitle'>#{t.capitalize}</h2>" +
+                      html_tag_links(tag) +
+                      "<h4 class='back'><a href='../index.html'>Home</a></h4>" +
+                      html_tag_files([tag, t]))
+      }
+    }
+  end
+
+  def save_html(file, text)
+    html = IO.read(File.join(@dir_base, 'index_pre.html')) +
+        text +
+        IO.read(File.join(@dir_base, 'index_post.html'))
+    IO.write(File.join(@dir_base, file), html)
+  end
+
+  def html_tag_links(tag)
+    "<h3>" + ([:all] + get_tags(tag) - [tag]).collect { |t|
+      "<a href='#{tag}_#{t}.html'>#{t.capitalize}</a>"
+    }.join(" - ") + '</h3>'
+  end
+
+  def html_tag_files(tags)
+    "<div class='files'><ul>\n" +
+        DFiles.search_by_all(:tags, tags.to_a).collect { |df|
+          "<li><a href='../files/#{df.save_file}'>" +
+              "#{df.name}</a> - #{df.desc} - " +
+              "<a href='#{df.url_page}'>#{df.url_page}</a>" +
+              "</li>"
+        }.join("\n") +
+        "</ul></div>"
+  end
+
+  # Returns a hash of the file-content
+  def self.hash(name)
+    if File.exists?(name)
+      return IO.read(name).bytes.inject { |a, b| a + a * b } % (2**64-1)
+    end
+    return 0
+  end
+end
+
+class DFile < Entity
+  def print
+    p self
+  end
+
+  def get_tag_prio(tag)
+    p, _ = tags.find { |_, t|
+      t == tag }
+    return p ? p.to_i : nil
+  end
+end
+
+# Singleton entity which holds the configuration
+class DFileConfigs < Entities
+  def setup_data
+    # 0 for no limit, else limit in GBytes
+    value_int :limit_size
+    # at what time of the day the system should update
+    # -1 = no auto_update
+    value_int :auto_update
+  end
+
+  def migration_1(d)
+    d.limit_size = 10
+    d.auto_update = -1
+  end
+
+  def self.singleton
+    first or
+        self.create({limit_size: 10, auto_update: -1})
+  end
+end
+
+class DFileConfig < Entity
+  def self.method_missing(m, *args)
+    dputs(4) { "#{m} - #{args.inspect} - #{DFileConfigs.singleton.inspect}" }
+    if args.length > 0
+      DFileConfigs.singleton.send(m, *args)
+    else
+      DFileConfigs.singleton.send(m)
+    end
+  end
+
+  def self.respond_to?(cmd)
+    DFileConfigs.singleton.respond_to?(cmd)
+  end
+end
+
+class DFilePriorities < Entities
+  def setup_data
+    value_int :priority
+    value_str :tags_str
+  end
+
+  def load(has_static = true)
+    delete_all
+    config = File.join(DFiles.dir_base, 'priorities')
+    if File.exists?(config)
+      IO.readlines(config).each { |l|
+        case l[0]
+          when '#'
+            #comment
+          when /[0-9]/
+            # We have a priority
+            priority, tags = l.chomp.split(' ', 2)
+            DFilePriorities.create({priority: priority.to_i, tags_str: tags})
+          else
+            # Should be the space
+            DFileConfig.limit_size = l.sub(/.*=/, '').to_i
+        end
+      }
+    end
+  end
+
+  def save
+
+  end
+
+  # Uses DFilePriorities to decide which files are most important
+  def get_most_wanted
+    files = []
+
+    # First add all matching tags for every priority of 1-5
+    (1..5).to_a.each { |p|
+      search_all_.each { |fp|
+        if p == fp.priority
+          dputs(4) { "Adding files #{fp.get_files} for prio #{p}" }
+          files.push(*fp.get_files)
+        end
+      }
+    }
+
+    # Then add all other priorities for every line in DFilePriorities
+    search_all_.each { |fp|
+      if fp.priority >= 6
+        dputs(4) { "Adding files #{fp.get_files} for #{fp.inspect}" }
+        files.push(*fp.get_files)
+      end
+    }
+
+    files.uniq
+  end
+end
+
+
+class DFilePriority < Entity
+  def get_files
+    #dputs_func
+    # Search for all tags, then filter according to priorities
+    dputs(4) { "Searching tags #{tags.to_s} in #{self.inspect}" }
+    DFiles.search_by_all(:tags, tags).select { |df|
+      dputs(4) { "Searching DFile #{df.inspect}" }
+      prio_min = 10
+      df.tags.each { |prio, tag|
+        if tags.index(tag)
+          prio_min = [prio_min, prio.to_i].min
+        end
+      }
+
+      # This will return nil if the priority is not matched,
+      # else the priority found, which will be evaluated by
+      # the select above to be true.
+      if prio_min <= priority.to_i
+        dputs(3) { "Found tags #{tags} with priority #{prio_min}" }
+        df.priority = prio_min
+      end
+    }
+  end
+
+  def tags
+    tags_str.split(' ')
+  end
+end
+
+=begin
+files.ndjair.net
+
+- copy from profeda.org to markas-al-nour.org
+- only serve completed copies
+- copy Antivirus first, then other things
+
+- copy from profeda.org to external hard-disk
+
+- copy from external hard-disk to cubox
+- only copy up to N GB of files
+- separated into categories
+- every category has it’s preference
+
+- present as web-page
+- first use dokuwiki
+- then use static pages
+
+-> move all .file in one directory
+-> move all files in another directory
+-> use hard links to re-create the ./update-files-structure
+-> update .file-directory using rsync
+-> update binary directory according to .file, priority
+
+- priority
+- each line contains the tags/directories and a priority
+- first lines have highest priority, last lines are pruned first if too much space
+- 1-5 are pruned in order of importance
+- 6-9 are more important at the beginning
+- 1 is pruned last
+- if more than one tag is given, the lowest priority in the description is taken for
+comparison. So a "3 windows\n1 antivirus"-description would not fit the 1st line, but
+it would fit the 2nd line as priority of 1
+
+SPACE=10G
+1 windows
+2 windows antivirus
+9 medias
+
+- .file
+add a priority-field: 1 is most important, 9 is least important, for each category
+
+- decision which files to include
+  1. make list of all files with sizes according to ‘priority’
+  2. if total > SPACE
+  2.1. starting from the last line in ‘priority’, remove 9 through 6, repeat up the list until SPACE is met
+  2.2 if total > SPACE
+  2.2.1 prune ‘priority’ 5 to 1, one priority at the time, from end to beginning, starting with biggest files first
+
+-> make list and delete from end till space-requirement is met:
+  - from priority 1 to priority 5 for all lines, collect files, starting with smallest
+  - from first to last line in list do priorities 6 to 9 from smallest to tallest
+=end