qooxview 1.9.9

data/lib/qooxview/frontend/source/class/frontend/simulation/DemoSimulation.js

@@ -0,0 +1,42 @@
+/* ************************************************************************
+
+   Copyright:
+
+   License:
+
+   Authors:
+
+************************************************************************ */
+
+/**
+ * This class demonstrates how to define simulated interaction tests for your 
+ * application. See the manual for details:
+ * {@link http://manual.qooxdoo.org/3.0.1/pages/development/simulator.html}
+ */
+qx.Class.define("frontend.simulation.DemoSimulation", {
+
+  extend : simulator.unit.TestCase,
+  
+  members :
+  {
+    /*
+    ---------------------------------------------------------------------------
+      TESTS
+    ---------------------------------------------------------------------------
+    */
+    
+    /** Check if a widget is present (part of the DOM) */
+    testButtonPresent : function()
+    {
+      this.assertNotNull(this.getSimulation().getWidgetOrNull("qxh=qx.ui.form.Button"), "Button widget not present!");
+    },
+    
+    /** Click a button and check if an alert box pops up */
+    testButtonClick : function()
+    {
+      this.getQxSelenium().qxClick("qxh=qx.ui.form.Button");
+      this.assertEquals("true", String(this.getQxSelenium().isAlertPresent()));
+    }
+  }
+  
+});

data/lib/qooxview/frontend/source/class/frontend/test/DemoTest.js

@@ -0,0 +1,55 @@
+/* ************************************************************************
+
+   Copyright:
+
+   License:
+
+   Authors:
+
+************************************************************************ */
+
+/**
+ * This class demonstrates how to define unit tests for your application.
+ *
+ * Execute <code>generate.py test</code> to generate a testrunner application 
+ * and open it from <tt>test/index.html</tt>
+ *
+ * The methods that contain the tests are instance methods with a 
+ * <code>test</code> prefix. You can create an arbitrary number of test 
+ * classes like this one. They can be organized in a regular class hierarchy, 
+ * i.e. using deeper namespaces and a corresponding file structure within the 
+ * <tt>test</tt> folder.
+ */
+qx.Class.define("frontend.test.DemoTest",
+{
+  extend : qx.dev.unit.TestCase,
+
+  members :
+  {
+    /*
+    ---------------------------------------------------------------------------
+      TESTS
+    ---------------------------------------------------------------------------
+    */
+  
+    /**
+     * Here are some simple tests
+     */
+    testSimple : function()
+    {
+      this.assertEquals(4, 3+1, "This should never fail!");
+      this.assertFalse(false, "Can false be true?!");
+    },
+
+    /**
+     * Here are some more advanced tests
+     */
+    testAdvanced: function () 
+    {
+      var a = 3;
+      var b = a;
+      this.assertIdentical(a, b, "A rose by any other name is still a rose");
+      this.assertInRange(3, 1, 10, "You must be kidding, 3 can never be outside [1,10]!");
+    }
+  }
+});

data/lib/qooxview/frontend/source/class/frontend/theme/Appearance.js

@@ -0,0 +1,18 @@
+/* ************************************************************************
+
+   Copyright:
+
+   License:
+
+   Authors:
+
+************************************************************************ */
+
+qx.Theme.define("frontend.theme.Appearance",
+{
+  extend : qx.theme.modern.Appearance,
+
+  appearances :
+  {
+  }
+});

data/lib/qooxview/frontend/source/class/frontend/theme/Color.js

@@ -0,0 +1,18 @@
+/* ************************************************************************
+
+   Copyright:
+
+   License:
+
+   Authors:
+
+************************************************************************ */
+
+qx.Theme.define("frontend.theme.Color",
+{
+  extend : qx.theme.modern.Color,
+
+  colors :
+  {
+  }
+});

data/lib/qooxview/frontend/source/class/frontend/theme/Decoration.js

@@ -0,0 +1,18 @@
+/* ************************************************************************
+
+   Copyright:
+
+   License:
+
+   Authors:
+
+************************************************************************ */
+
+qx.Theme.define("frontend.theme.Decoration",
+{
+  extend : qx.theme.modern.Decoration,
+
+  decorations :
+  {
+  }
+});

data/lib/qooxview/frontend/source/class/frontend/theme/Font.js

@@ -0,0 +1,18 @@
+/* ************************************************************************
+
+   Copyright:
+
+   License:
+
+   Authors:
+
+************************************************************************ */
+
+qx.Theme.define("frontend.theme.Font",
+{
+  extend : qx.theme.modern.Font,
+
+  fonts :
+  {
+  }
+});

data/lib/qooxview/frontend/source/class/frontend/theme/Theme.js

@@ -0,0 +1,21 @@
+/* ************************************************************************
+
+   Copyright:
+
+   License:
+
+   Authors:
+
+************************************************************************ */
+
+qx.Theme.define("frontend.theme.Theme",
+{
+  meta :
+  {
+    color : frontend.theme.Color,
+    decoration : frontend.theme.Decoration,
+    font : frontend.theme.Font,
+    icon : qx.theme.icon.Tango,
+    appearance : frontend.theme.Appearance
+  }
+});

data/lib/qooxview/frontend/source/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width; initial-scale=1.0; maximum-scale=4.0; user-scalable=1;"/>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+    <title>Frontend</title>
+    <script type="text/javascript" src="/source/class/frontend/globals.js"></script>
+    <script type="text/javascript" src="script/frontend.js?md5sum_frontend"></script>
+</head>
+<body></body>
+</html>

data/lib/qooxview/frontend/source/translation/readme.txt

@@ -0,0 +1,3 @@
+This directory will contain translation (.po) files once you run the
+'translation' job in your project.
+

data/lib/qooxview/helpers/config_base.rb

@@ -0,0 +1,264 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+require 'observer'
+
+class ConfigBases < Entities
+  include Observable
+
+  def setup_data
+    value_block :wide
+    value_list :functions, 'ConfigBases.list_functions'
+    value_str :dputs_logfile
+    value_text :welcome_text
+
+    value_block :narrow
+    value_str :locale_force
+    value_str :version_local
+    value_str :use_printing
+    value_list_drop :openprint_simul, '%w(true false)'
+    value_str :openprint_search
+    value_int :debug_lvl
+    value_list_drop :dputs_show_time, '%w(false min sec)'
+    value_list_drop :dputs_silent, '%w(false true)'
+    value_int :dputs_terminal_width
+    value_int :block_size
+    value_int :max_upload_size
+
+    @@functions = []
+    @@functions_base = {}
+    @@functions_conflict = []
+
+    respond_to? :add_config and add_config
+
+    return true
+  end
+
+  def migration_1(c)
+    c._debug_lvl = DEBUG_LVL
+    c._locale_force = 'fr'
+    c._version_local = 'orig'
+    c._welcome_text = 'Welcome to Profeda'
+    # Values for slow, buggy lines. For a good transfer-rate, choose 16x more
+    c._block_size = 4096
+    c._max_upload_size = 65_536
+    c.dputs_logfile = '/var/log/gestion/events.log'
+    c.dputs_show_time = %w(min)
+    c.dputs_silent = %w(false)
+    c.dputs_terminal_width = 160
+    c.openprint_simul = %w(false)
+    c.openprint_search = '.*'
+
+    dputs(3) { "Migrating out: #{c.inspect}" }
+  end
+
+  def call_changed(action, value, old)
+    ConfigBases.singleton.update(action, value, old)
+    changed
+    notify_observers(action, value, old)
+  end
+
+  def functions
+    @@functions
+  end
+
+  def functions_base
+    @@functions_base
+  end
+
+  def functions_conflict
+    @@functions_conflict
+  end
+
+  def list_functions
+    self.list_functions
+  end
+
+  def init
+    Entities.ConfigBases.load
+    ConfigBases.singleton
+    ConfigBases.migrate
+  end
+
+  def self.singleton
+    first or
+        self.create({:functions => [], :locale_force => nil, :welcome_msg => ''})
+  end
+
+  def self.list_functions
+    index = 0
+    @@functions.collect { |f|
+      index += 1
+      [index, f.to_sym]
+    }
+  end
+end
+
+
+class ConfigBase < Entity
+  def setup_instance
+    dputs(4) { "Setting up ConfigBase with debug_lvl = #{debug_lvl}" }
+    if !Object.const_defined? :DEBUG_LVL
+      self.debug_lvl = debug_lvl
+    end
+    DPuts.silent = dputs_silent == %w(true)
+    DPuts.show_time = (dputs_show_time || %w(min)).first
+    DPuts.terminal_width = (dputs_terminal_width || 160).to_i
+    is_loading { setup_defaults }
+  end
+
+  def setup_defaults
+  end
+
+  def is_loading
+    oldloading = @loading
+    @loading = true
+    yield
+    @loading = oldloading
+  end
+
+  def data_set(field, value)
+    old = data_get(field)
+    ret = super(field, value)
+    if !@loading
+      return if old == value
+      dputs(3) { "Updating #{field} to #{value.inspect}, #{old.inspect}" }
+      if field == :functions
+        if (del = old - value).length > 0
+          @proxy.call_changed(:function_del, del, nil)
+        end
+        if (add = value - old).length > 0
+          @proxy.call_changed(:function_add, add, nil)
+        end
+      else
+        @proxy.call_changed(field, value, old)
+      end
+    end
+    ret
+  end
+
+  def update(action, value, old = nil)
+    dputs(3) { "No action #{action.inspect} changed to #{value.inspect} from #{old.inspect}" }
+    #super(action, value, old)
+  end
+
+  def save_block_to_object(block, obj)
+    dputs(3) { "Pushing block #{block} to object #{obj.name}" }
+    ConfigBases.get_block_fields(block).each { |f|
+      value = data_get(f)
+      dputs(3) { "Setting #{f} in #{block} to #{value}" }
+      obj.send("#{f}=", value)
+    }
+  end
+
+  def debug_lvl=(lvl)
+    dputs(4) { "Setting debug-lvl to #{lvl}" }
+    data_set(:_debug_lvl, lvl.to_i)
+    Object.const_defined?(:DEBUG_LVL) and Object.send(:remove_const, :DEBUG_LVL)
+    Object.const_set(:DEBUG_LVL, lvl.to_i)
+  end
+
+  def dputs_show_time=(t)
+    DPuts.show_time = (self._dputs_show_time = t).first
+  end
+
+  def dputs_silent=(s)
+    DPuts.silent = (self._dputs_silent = s) == %w(true)
+  end
+
+  def dputs_terminal_width=(w)
+    DPuts.terminal_width = (self._dputs_terminal_width = w).to_i
+  end
+
+  def to_hash
+    super.merge(:functions => get_functions_numeric)
+  end
+
+  def get_functions
+    functions.to_sym
+  end
+
+  def get_functions_numeric
+    functions.collect { |f|
+      @proxy.functions.index(f.to_sym) + 1
+    }
+  end
+
+  def self.get_functions
+    ConfigBases.singleton.get_functions
+  end
+
+  def self.get_functions_numeric
+    ConfigBases.singleton.get_functions_numeric
+  end
+
+  def self.store(c = {})
+    #dputs_func
+    if c.has_key? :functions
+      funcs = c._functions
+      dputs(4) { "Storing functions: #{funcs.inspect}" }
+      if funcs.index { |i| i.to_s.to_i.to_s == i.to_s }
+        dputs(3) { 'Converting numeric to names' }
+        funcs = funcs.collect { |d|
+          ConfigBases.functions[d-1].to_sym
+        }
+      else
+        funcs.to_sym!
+      end
+      funcs.each { |f|
+        ConfigBases.functions_base.each { |k, v|
+          if v.index(f)
+            dputs(2) { "Adding #{k.inspect} to #{f}" }
+            funcs.push k.to_sym
+          end
+        }
+      }
+      funcs.flatten!
+      ConfigBases.functions_conflict.each { |f|
+        dputs(4) { "Testing conflict of #{f}" }
+        list = f.collect { |g|
+          funcs.index(g)
+        }.select { |l| l }.sort
+        dputs(4) { "List is #{list.inspect}" }
+        if list.length > 1
+          list.pop
+          dputs(4) { "Deleting #{list.inspect}" }
+          list.each { |l| funcs.delete_at(l) }
+        end
+      }
+      c[:functions] = funcs
+    end
+    dputs(4) { "Storing #{c.inspect}" }
+    ConfigBases.singleton.data_set_hash(c)
+    ConfigBase.setup_defaults
+    View.update_configured_all
+  end
+
+  def self.method_missing(m, *args)
+    dputs(4) { "#{m} - #{args.inspect} - #{ConfigBases.singleton.inspect}" }
+    if args.length > 0
+      ConfigBases.singleton.send(m, *args)
+    else
+      ConfigBases.singleton.send(m)
+    end
+  end
+
+  def self.respond_to?(cmd)
+    ConfigBases.singleton.respond_to?(cmd)
+  end
+
+  def self.has_function?(func)
+    ConfigBase.get_functions.index(func.to_sym) != nil
+  end
+
+  def self.set_functions(func)
+    self.store({:functions => func.collect{|f| f.to_sym}})
+  end
+
+  def self.add_function(func)
+    self.store({:functions => self.get_functions.push(func.to_sym)})
+  end
+
+  def self.del_function(func)
+    self.store({:functions => self.get_functions.reject { |f| f == func.to_sym }})
+  end
+end

data/lib/qooxview/helpers/icc.rb

@@ -0,0 +1,222 @@
+# This will be the only InterCenterCommunication-point to "Gestion"
+# TODO
+# - secure connection
+# Implemented:
+# - simple get-function
+# - longer post-function
+# - put json around everything
+require 'cgi'
+require 'net/http'
+#require 'helper_classes/hashaccessor'
+
+class ICC < RPCQooxdooPath
+  @@transfers = {}
+
+  def self.response(code, msg, json: true)
+    if json
+      {code: code, msg: msg}.to_json
+    else
+      {code: code, msg: msg}
+    end
+  end
+
+  def self.parse_req(req)
+    #dputs(4) { "Request: #{req.inspect}" }
+    #dputs_func
+    if req.request_method == 'POST'
+      path, query, addr = req.path, req.query.to_sym, RPCQooxdooHandler.get_ip(req)
+      dputs(4) { "Got query: #{path} - #{query.inspect} - #{addr}" }
+
+      if query._cmdkey == 'start'
+        log_msg :ICC, "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 => [])
+          d._chunks > 0 and return self.response('OK', 'send data')
+          query._cmdkey = d._tid
+          query._data = []
+        else
+          dputs(3) { "User #{d._user.inspect} with pass #{d._pass.inspect} unknown" }
+          return self.response('Error', 'authentication')
+        end
+      end
+      if tr = @@transfers[query._cmdkey]
+        counter = query._counter.to_i
+        dputs(2) { "Found transfer-id #{query._cmdkey}/"+
+            "#{counter+1}/#{tr._chunks} - #{tr._method}" }
+        if tr._data[counter]
+          dputs(1) { "Received block #{counter} double - discarding" }
+        else
+          tr._data[counter] = query._data
+          if counter == tr._chunks - 1
+            tr._data = tr._data.join
+            if Digest::MD5.hexdigest(tr._data) == tr._md5
+              dputs(1) { "Successfully received cmdkey #{query._cmdkey}" }
+              ret = self.response('OK', self.data_received(tr))
+            else
+              dputs(1) { "cmdkey #{tr._cmdkey} transmitted with errors, " +
+                  "#{Digest::MD5.hexdigest(tr._data)} instead of #{tr._md5}" }
+              ret = self.response('Error', 'wrong MD5')
+            end
+            @@transfers.delete query._cmdkey
+            return ret
+          else
+            return self.response('OK', "send #{tr._chunks - counter - 1} more chunks")
+          end
+        end
+      end
+      return self.response('Error', 'must start or use existing cmdkey')
+    else # GET-request
+      path = /.*\/([^\/]*)\/([^\/]*)$/.match(req.path)
+      dputs(3) { "Path #{req.path} is #{path.inspect}" }
+      query = CGI.parse(req.query_string)
+      log_msg :ICC, "Got query: #{path.inspect} - #{query}"
+      ret = ICC.request(path[1], path[2], query)
+      if ret.to_s.length < 512
+        log_msg :ICC, "Returning #{ret}"
+      else
+        log_msg :ICC, "Returning #{JSON.parse(ret)._code}: #{ret.to_s.length} bytes"
+      end
+      ret
+    end
+  end
+
+  def self.request(entity_name, m, query_json)
+    m =~ /^icc_/ and log_msg :ICC, "Method #{m} includes 'icc_' - probably not what you want"
+    binary = m[0] == '_'
+    method = "icc_#{m.sub(/^_/, '')}"
+    if en = Object.const_get(entity_name)
+      dputs(3) { "Sending #{method} to #{entity_name}" }
+      query={}
+      begin
+        query_json.each_pair { |k, v| query[k] = JSON.parse(v.first) }
+      rescue JSON::ParserError => e
+        dputs(0) { "Error parsing #{query_json}" }
+        dputs(0) { "#{e.inspect}" }
+        dputs(0) { "#{caller.inspect}" }
+        return self.response('Error', log_msg(:ICC, "Object couldn't be parsed"))
+      end
+      dputs(3) { "Found query #{query.inspect}" }
+      if query.has_key?('icc_data')
+        query = query._icc_data
+        dputs(3) { "Found icc_data in query, is now: #{query.inspect}" }
+      end
+      msg = en.send(method, query)
+      if msg =~ /^Error:/
+        self.response('Error', msg)
+      else
+        self.response('OK', binary ? Base64::encode64(msg.force_encoding(Encoding::ASCII_8BIT)) :
+                              msg)
+      end
+    else
+      self.response('Error', log_msg(:ICC, "Object #{entity_name} doesn't exist"))
+    end
+  end
+
+  def self.data_received(tr)
+    if tr._method.sub!(/^json@/, '')
+      tr._data = JSON.parse(tr._data).first
+    end
+    entity_name, m = tr._method.split('.')
+    method = "icc_#{m}"
+    Object.const_get(entity_name)
+    if en = Object.const_get(entity_name) # and en.respond_to? method
+      dputs(3) { "Sending #{method} to #{entity_name}" }
+      en.send(method, tr)
+    else
+      log_msg :ICC, "Error: Object #{entity_name} has no method #{method}"
+    end
+  end
+
+  def self.send_post(url, cmdkey, data, counter: 0, retries: 4)
+    path = URI.parse(url)
+    post = {:cmdkey => cmdkey, :data => data, :counter => counter}
+    dputs(3) { "Sending to #{path.inspect}: #{cmdkey}/#{count}" }
+    err = self.response('Error', 'Unknown', json: false)
+    (1..retries).each { |i|
+      begin
+        ret = Net::HTTP.post_form(path, post)
+        dputs(2) { "Return-value is #{ret.inspect}, #{ret.message}, #{ret.code}, body is #{ret.body}" }
+        if ret.code.to_i == 200
+          begin
+            return JSON.parse(ret.body)
+          rescue JSON::ParserError
+            dputs(1) { "Couldn't parse #{ret.body}" }
+            err._msg = 'Reply parse-error'
+            sleep 5
+          end
+        else
+          dputs(1) { "Error-reply was #{ret.inspect}" }
+          err._msg = "Error: #{ret.code}:#{ret.message}"
+          sleep 5
+        end
+      rescue Timeout::Error
+        dputs(1) { 'Timeout occured' }
+        err._msg = 'Timeout occured'
+      rescue Errno::ECONNRESET
+        dputs(1) { 'Connection reset' }
+        err._msg = 'Connection reset'
+      end
+    }
+    return err
+  end
+
+  def self.transfer(login, method, transfer = '', url: ConfigBase.server_uri, json: true,
+      &percent)
+    block_size = ConfigBase.block_size.to_i
+    if block_size < 128
+      dputs(0) { "Unacceptable block-size of #{block_size}" }
+      return self.response('Error', 'No block-size', json: false)
+    end
+    if json
+      method.prepend 'json@'
+      transfer = [transfer].to_json
+    end
+
+    transfer_md5 = Digest::MD5.hexdigest(transfer)
+    t_array = []
+    while t_array.length * block_size < transfer.length
+      start = (block_size * t_array.length)
+      t_array.push transfer[start..(start+block_size -1)]
+    end
+    dputs(2) { "Transfer-size is #{transfer.size} and cut up in "+
+        "#{t_array.size} pieces of #{block_size} length" }
+
+    dputs(3) { "Going to transfer: #{t_array.inspect}" }
+    percent and percent.call('0%')
+    tid = Digest::MD5.hexdigest(rand.to_s)
+    ret = ICC.send_post(url, :start,
+                        {:method => method, :chunks => t_array.length,
+                         :md5 => transfer_md5, :tid => tid,
+                         :user => login.login_name, :pass => login.password_plain}.to_json)
+    return ret if ret._code == 'Error'
+    t_array.each_index { |i|
+      if percent
+        p = "#{((i+1) * 100 / t_array.length).floor}%"
+        percent.call p
+        dputs(3) { "Percentage done: #{p}" }
+      end
+      dputs(2) { "Sending id #{tid}/#{i+1}" }
+      ret = ICC.send_post(url, tid, t_array[i], counter: i)
+      return ret if ret =~ /^Error:/
+    }
+    return ret
+  end
+
+  def self.get(entity_name, method, args: {}, url: ConfigBase.server_uri)
+    args_json = {icc_data: args.to_json}
+    path = URI.parse("#{url}/#{entity_name}/#{method}?#{URI.encode_www_form(args_json)}")
+    begin
+      ret = JSON::parse(Net::HTTP.get(path))
+      method[0] == '_' and ret._msg = Base64::decode64(ret._msg)
+      ret
+    rescue JSON::ParserError => e
+      {code: 'error', msg: "error: #{e}"}
+    rescue SocketError => e
+      {code: 'error', msg: "Error: timeout #{e}"}
+    end
+  end
+
+end