qooxview 1.9.9

data/lib/qooxview/helpers/vtlist_pane.rb

@@ -0,0 +1,158 @@
+=begin
+ViewType ListPane - a simple interface to use lists - rails-copy
+
+Usage:
+
+  include VTListPane
+
+  gui_vbox do
+    vtlp_list :names, 'nm'
+    show_button :delete
+  end
+  gui_vbox do
+    show_find :name
+    show_str :login
+    show_int :uid
+  end
+
+This will show a list with all available names. The data_class needs to have the following
+methods defined (they're already defined if ":nm" exists in data_class):
+
+  def list_nm
+  end
+  def find_nm
+  end
+
+The following buttons are defined:
+ - new - clear the fields
+ - save - saves the entry, eventually adding a new field
+ - delete - takes away the chosen entry
+=end
+
+module VTListPane
+  def vtlp_setup(field, method, *args)
+    @vtlp_field = field.to_s
+    @vtlp_method = method.to_s.sub(/^rev_/, "")
+    if args.length > 0 and args[0].class == String
+      @vtlp_method_list = args.shift
+    else
+      @vtlp_method_list = "listp_#{method.to_s}"
+    end
+    if args.length > 0 and args[0].class == Hash
+      args.shift
+    else
+      {}
+    end
+  end
+
+  def vtlp_list(field, method, *args)
+    @vtlp_use_entity = false
+    args_hash = vtlp_setup(field, method, *args)
+    show_list_single field, "Entities.#{@data_class.class.to_s}.#{@vtlp_method_list}",
+                     args_hash.merge(:callback => true)
+    self.class_eval <<-RUBY
+      def rpc_list_choice_#{field}( session, data )
+        rpc_list_choice_vtlistpanel( session, "#{field}", data )
+      end
+    RUBY
+  end
+
+  def vtlp_list_entity(field, entity, method, *args)
+    @vtlp_use_entity = true
+    args_hash = vtlp_setup(field, method, *args)
+    show_entity field, entity, 'single',
+                @vtlp_method,
+                args_hash.merge(:callback => true)
+  end
+
+  def vtlp_get_entity(d)
+    @vtlp_use_entity ? d : @data_class.get_data_instance(d[@vtlp_field][0])
+  end
+
+  def vtlp_update_list(session, choice = nil)
+    list = @data_class.send(@vtlp_method_list)
+    newval = (list + [choice]).compact
+    rep = reply(:empty_update, @vtlp_field => newval)
+
+    if @update
+      rep += rpc_update(session)
+    end
+    rep
+  end
+
+  def rpc_button_new(session, data)
+    reply(:empty, empty_fields) +
+        vtlp_update_list(session)
+  end
+
+  def rpc_button_delete(session, data)
+    dputs(3) { "session, data: #{[session, data.inspect].join(':')}" }
+    id = vtlp_get_entity(data)
+    dputs(3) { "Got #{id.inspect}" }
+    if id
+      dputs(2) { "Deleting entry #{id}" }
+      id.delete
+    end
+
+    vtlp_update_list(session)
+  end
+
+  def rpc_button_save(session, data)
+    field = vtlp_get_entity(data)
+    dputs(3) { "Field is #{field.inspect}, setting data #{data.inspect}" }
+    selection = data[@vtlp_field][0]
+    if field
+      field.data_set_hash(data.to_sym)
+    else
+      if data[@vtlp_method].to_s.length > 0
+        n = @data_class.create(data.to_sym)
+        selection = n.id
+      else
+        dputs(0) { "Didn't have a #{@vtlp_method}" }
+      end
+    end
+    dputs(3) { "vtlp_method is #{@vtlp_method} - selection is #{selection.inspect}" }
+    vtlp_update_list(session, selection)
+  end
+
+  def empty_fields
+    layout_recurse.select { |l|
+      !%w(list button entity).index(l.dtype.to_s)
+    }.collect { |l| l.name }
+  end
+
+  def rpc_list_choice_vtlistpanel(session, name, data)
+    #dputs_func
+    ret = if @update and @update == :before
+            rpc_update(session)
+          else
+            []
+          end
+    dputs(3) { "rpc_list_choice with #{name} - #{data.inspect}" }
+    if name == @vtlp_field
+      dputs(4) { layout_recurse.collect { |l| "#{l.name}::#{l.dtype}" }.join(' - ') }
+      dputs(4) { empty_fields.join(' - ') }
+      ret = reply(:empty, empty_fields)
+      item = if @vtlp_use_entity
+               field_value = data[name].get_unique
+               data[name]
+             else
+               field_value = data[name][0]
+               dputs(4) { "replying with field_value of #{field_value}" }
+               vtlp_get_entity(data)
+             end
+      dputs(4) { "item is #{item.inspect}" }
+      if item
+        ret += reply(:update, item.to_hash)
+      end
+      ret += reply(:update, {@vtlp_field.to_sym => [field_value]})
+      session.s_data[@vtlp_field.to_sym] = field_value
+    end
+    if @update and @update != :before
+      ret += rpc_update(session)
+    end
+
+    dputs(3) { "reply is #{ret.inspect}" }
+    ret
+  end
+end

data/lib/qooxview/helpers/welcome.rb

@@ -0,0 +1,55 @@
+class Welcome < View
+  attr_accessor :no_login
+
+  def layout
+    gui_vbox :nogroup do
+      gui_hbox :nogroup do
+        gui_fields :nogroup do
+        end
+        show_str :username
+        show_pass :password
+        show_str_ro :version
+        show_button :simple_connect, :direct_connect
+        gui_fields :nogroup do
+        end
+      end
+
+      gui_window :login_failed do
+        show_html :reason
+        show_button :try_again
+      end
+      if ConfigBase.welcome_text
+        gui_vbox :nogroup do
+          show_html :links
+        end
+      end
+    end
+
+    dputs(5) { "#{@layout.inspect}" }
+    @visible = false
+    @no_login ||= false
+  end
+
+  def rpc_show(session)
+    dputs(3) { self.inspect }
+    if @no_login
+      dputs(2) { 'No login is enabled' }
+      session
+      return reply(:session_id, session.sid) +
+          View.rpc_list(session)
+    else
+      dputs(2) { 'Login is enabled' }
+      super(session) + reply(:hide, :direct_connect)
+    end
+  end
+
+  def self.nologin
+    dputs(2) { 'Going for no login' }
+    $config.__Views.__Welcome.__no_login = true
+    View.Welcome.no_login = true
+  end
+
+  def rpc_button_try_again(session, data)
+    reply(:window_hide)
+  end
+end

data/lib/qooxview/qooxview.rb

@@ -0,0 +1,175 @@
+
+
+#QOOXVIEW_DIR=%x[ echo $PWD/#{File.dirname(__FILE__)}].chomp
+QOOXVIEW_DIR=File.dirname(__FILE__)
+
+require 'helper_classes/dputs'
+include HelperClasses::DPuts
+extend HelperClasses::DPuts
+if not defined?(DEBUG_LVL)
+  # Unknown debug-level for recognition in ConfigBase
+  DEBUG_LVL = 0.5
+end
+
+require 'yaml'
+require 'active_record'
+require 'json'
+require 'gettext'
+require 'qooxview/rpcqooxdoo'
+require 'qooxview/entity'
+require 'qooxview/view'
+require 'qooxview/additions'
+require 'qooxview/config_yaml'
+require 'getoptlong'
+require 'gettext'
+require 'gettext/tools/msgfmt'
+require 'gettext/tools/msgmerge'
+require 'gettext/tools/xgettext'
+Dir.glob(__dir__+'/helpers/*').each { |f|
+  require f
+}
+
+$qooxview_cmds = []
+
+module QooxView
+  def self.do_opts(dir_entities, dir_views)
+    opts = GetoptLong.new(
+        ['--help', '-h', GetoptLong::NO_ARGUMENT],
+        ['--i18n', '-t', GetoptLong::OPTIONAL_ARGUMENT],
+        ['--po', '-p', GetoptLong::NO_ARGUMENT],
+        ['--archive', '-a', GetoptLong::OPTIONAL_ARGUMENT]
+    )
+    opts.each { |o, a|
+      case o
+        when '--help'
+          puts "Usage: #{$0} [-t] [--help]"
+          puts "\t-t [lang]\tUpdate translations - takes an optional language-argument"
+          puts "\t-p\tCreate .mo-files"
+          puts "\t--help\tShow this help"
+          raise 'PrintHelp'
+        when '--i18n'
+          potfile = "po/#{$name}.pot"
+          %x[ mkdir -p po; rm -f #{potfile} ]
+          paths = ["#{dir_entities}/*.rb", "#{dir_views}/*.rb", "#{dir_views}/*/*.rb"]
+          dputs(2) { "potfile is #{potfile.inspect}, paths is #{paths.collect { |p| Dir[p] }}" }
+          #GetText::Tools::XGetText.run( paths.collect{|p| Dir[p] }.flatten.concat( [ "-o", "#{potfile}" ] ) )
+          GetText::Tools::XGetText.run(*paths.collect { |p| Dir[p] }.concat(
+                                           %W(-o #{potfile})).flatten)
+          if a.length > 0
+            pofile = "po/#{$name}-#{a}.po"
+            if File.exists? pofile
+              %x[ mv #{pofile} #{pofile}.tmp ]
+              #%x[ msgmerge #{pofile}.tmp #{potfile} -o #{pofile} ]
+              # Should be possible with rmsgmerge, but it didn't work :(
+              GetText::Tools::MsgMerge.run("#{pofile}.tmp", potfile, '-o', pofile)
+              %x[ rm #{pofile}.tmp ]
+            else
+              %x[ cp #{potfile} #{pofile} ]
+            end
+          end
+          raise 'UpdatePot'
+        when '--po'
+          dputs(2) { 'Making mo-files' }
+          Dir.glob("po/#{$name}-*.po").each { |po|
+            lang = po.match(/.*#{$name}-(.*).po/)[1]
+            path = "po/#{lang}/LC_MESSAGES"
+            dputs(2) { "Doing po-file #{po} for language #{lang} with path #{path}" }
+            if not %x[ mkdir -p #{path}] or not GetText::Tools::MsgFmt.run(po, "-o#{path}/#{$name}.mo")
+              dputs(0) { "Error: can't make mo-files, exiting" }
+              exit
+            end
+          }
+          raise 'MakeMo'
+        when '--archive'
+          dputs(2) { 'Going to archive AfriCompta' }
+          $qooxview_cmds.push [:archive, a]
+      end
+    }
+  end
+
+  def self.init(dir_entities = nil, dir_views = nil)
+    #dputs_func
+    if not (Module.constants.index('Test') or Module.constants.index(:test))
+      dputs(2) { 'Doing options' }
+      self.do_opts(dir_entities, dir_views)
+    end
+
+    # Include all modules in the dir_entities and dir_views
+    # directories
+    dputs(2) { "Starting init with entities:views = #{[dir_entities, dir_views].join(':')}" }
+    [dir_entities, dir_views].each { |d|
+      if d
+        dputs(2) { "Initializing directory #{d}" }
+        Dir[d+'/**/*.rb'].each { |f|
+          dputs(3) { "Requiring file #{f}" }
+          require(f)
+        }
+      end
+    }
+
+    if not Permission.list.index('default')
+      Permission.add('default', '.*')
+    end
+
+    dputs(2) { 'Starting RPCQooxdooServices' }
+    # We want to load an eventual ConfigBase first, so that other modules can
+    # read the configuration
+    rpcqooxdoo = RPCQooxdooService.new('Entities.ConfigBase')
+    if true
+      ConfigBases.init
+    else
+      Entities.ConfigBases.load
+      ConfigBases.singleton
+      Entities.ConfigBases.migrate
+    end
+    # Everything will be loaded just after, so make sure we have everything done
+    # when there is a migration
+    Entities.save_all
+
+    GetText.bindtextdomain($name, :path => 'po')
+    if ConfigBase.locale_force
+      dputs(3) { "Forcing locale to #{ConfigBase.locale_force}" }
+      GetText.locale = ConfigBase.locale_force
+    end
+    GetText::TextDomainManager.cached = false
+
+    # Get an instance of all Qooxdoo-services
+    rpcqooxdoo.get_services('^Entities.*')
+    Entities.load_all
+    rpcqooxdoo.get_services('^View.*')
+
+    $qooxview_cmds.each { |qv|
+      qv_cmd = qv.class == Array ? qv[0] : qv
+      dputs(2) { "Doing #{qv.inspect}" }
+      case qv_cmd
+        when :archive
+          month = qv[1] == '' ? 1 : qv[1]
+          dputs(2) { "Archiving with starting month #{month}" }
+          Accounts.archive(month)
+          exit
+      end
+    }
+  end
+
+  # The main function, used to start it all
+  def self.startWeb(port = 3302, duration = nil)
+    dputs(2) { "Configuring port for #{port}" }
+    # Suppose we've not being initialized when there are no permissions
+    if Permission.list.size == 0
+      self.init
+    end
+
+    # And start the webrick-server
+    # First check whether QooxDoo is running in source- or buid-mode
+    dir_html = File.exist?(QOOXVIEW_DIR + '/frontend/build/script/frontend.js') ?
+        'build' : 'source'
+    dputs(2) { "Directory for Frontend is: #{dir_html}" }
+
+    log_msg('main', 'Starting up')
+    if cmd = get_config(false, :startupCmd)
+      %x[ #{cmd} ]
+    end
+    RPCQooxdooHandler.webrick(port, QOOXVIEW_DIR + "/frontend/#{dir_html}/",
+                              duration)
+  end
+end