qooxview 1.9.9

data/lib/qooxview/helpers/make_steps.rb

@@ -0,0 +1,77 @@
+require 'helper_classes/system'
+
+class MakeSteps
+  attr_accessor :step, :status, :data, :auto_update
+  include HelperClasses
+
+  def initialize(session, wait = 0, &block)
+    @block = block
+    @oldstep = @step = 0
+    @wait = wait
+    session._s_data._make_step = self
+  end
+
+  def self.make_step(session, data = nil)
+    session._s_data._make_step.make_step(session, data)
+  end
+
+  def reply
+    #dputs_func
+    dputs(3){"Oldstep: #{@oldstep} - #{@step}"}
+    if @oldstep == @step && @step >= 0
+      @step += 1
+      dputs(3) { "Increasing step to #{@step}" }
+    end
+    @ret ||= []
+    dputs(3) { "#{@ret} :: #{status.inspect} :: #{@auto_update.inspect}" }
+    @ret.length == 0 and @ret = @status.to_a
+    @ret += View.reply(:auto_update, @auto_update.to_i)
+    dputs(3) { "ret is now #{@ret.inspect}" }
+    @auto_update = nil if (@wait == 0 || @step == -1)
+    dputs(3) { "Auto-update is #{@auto_update}" }
+    @status = nil
+    return @ret
+  end
+
+  def make_step(session, data = nil)
+    #dputs_func
+    dputs(3){"Oldstep in make_step: #{@oldstep}"}
+    if @wait.abs > 0
+      if !@thread
+        dputs(3) { 'Creating new thread' }
+        @thread = Thread.new {
+          System.rescue_all do
+            @oldstep = @step
+            dputs(3) { "Calling block for step #{@step}" }
+            begin
+              @ret = @block.yield(session, data, @step)
+            rescue LocalJumpError => e
+              dputs(3) { "LocalJump: #{e.inspect}" }
+              @ret = nil
+            end
+          end
+        }
+      end
+      (0..@wait.abs*10).each { |i|
+        dputs(4) { "Waiting #{i}" }
+        sleep 0.1
+        if !@thread.alive?
+          dputs(3) { "Got return-value #{@ret}" }
+          @thread = nil
+          return reply
+        end
+      }
+      View.reply(:auto_update, @wait) + @status.to_a
+    else
+      dputs(3) { "Calling block for step #{@step}" }
+      begin
+        @oldstep = @step
+        @ret = @block.yield(session, data, @step)
+      rescue LocalJumpError => e
+        dputs(3) { "LocalJump: #{e.inspect}" }
+        @ret = nil
+      end
+      reply
+    end
+  end
+end

data/lib/qooxview/helpers/migration_version.rb

@@ -0,0 +1,18 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+class MigrationVersions < Entities
+  def setup_data
+    value_str :class_name
+    value_int :version
+  end
+  
+  # These Entities don't migrate
+  def migrate
+  end
+end
+
+# This way MigrationVersions is instantiated immediately, instead of
+# any time later when calling QooxView.init
+RPCQooxdooService.add_prime_service( MigrationVersions,
+                                   'Entities.MigrationVersions')

data/lib/qooxview/helpers/open_print.rb

@@ -0,0 +1,286 @@
+=begin
+ Offers simple OpenOffice-find/replace stuff and printing 
+=end
+
+require 'rubygems'
+require 'docsplit'
+#require 'zip/zipfilesystem'; include Zip
+require 'zip'
+
+class OpenPrint
+  attr_accessor :lp_cmd, :file
+
+  def initialize(file, dir = nil)
+    @file = file
+    @dir = dir
+    @base = File.basename file
+    @lp_cmd = nil
+    @counter = 0
+  end
+
+  def replace_accents(str)
+    str = str.downcase.gsub(/ /, '_')
+    accents = Hash[*%w( a àáâä e éèêë i ìíîï o òóôöœ u ùúûü c ç ss ß )]
+    dputs(4) { "str was #{str}" }
+    accents.each { |k, v|
+      str.gsub!(/[#{v}]/, k)
+    }
+    str.gsub!(/[^a-z0-9_-]/, '_')
+    dputs(4) { "str is #{str}" }
+    str
+  end
+
+  def print_hash(fields, counter = nil, name = nil)
+    print(fields.collect { |k, v| [/--#{k}--/, v] }, counter, name)
+  end
+
+  def get_content
+    return unless File.exists? @file
+    Zip::File.open(@file) { |z|
+      z.read('content.xml').force_encoding(Encoding::UTF_8)
+    }
+  end
+
+  def print_file(pdf_file)
+    if @lp_cmd
+      dputs(2) { "Printing with --#{@lp_cmd} #{pdf_file}--" }
+      System.run_bool("#{@lp_cmd} #{pdf_file}")
+      return true
+    else
+      # Download PDF
+      return "#{pdf_file}"
+    end
+  end
+
+  def self.replace(doc, fields)
+    fields.each { |old, new|
+      doc.gsub!(old, new.to_s)
+      # For every -TAG- there can be a _TAG_ which is replaced with the
+      # uppercase-version of 'new'
+      old_up = old.inspect.sub(/^.-(.*)-.$/, '_\1_')
+      doc.gsub!(old_up, new.to_s.upcase)
+    }
+    doc
+  end
+
+  def make_pdf(fields = [], counter = nil, name = nil)
+    dputs(3) { "New print for -#{@file.inspect}-" }
+    if name
+      tmp_file = "/tmp/#{replace_accents(name)}.#{@base.sub(/.*\./, '')}"
+    else
+      counter ||= @counter
+      tmp_file = "/tmp/#{counter}-#{@base}"
+      @counter += 1
+    end
+    pdf_file = tmp_file.sub(/[^\.]*$/, 'pdf')
+    dputs(3) { "Copying to -#{tmp_file.inspect}-" }
+
+    FileUtils::cp(@file, tmp_file)
+    Zip::File.open(tmp_file) { |z|
+      doc = z.read('content.xml').force_encoding(Encoding::UTF_8)
+      OpenPrint.replace(doc, fields)
+      # Replace dates that need to be calculated with a '_'
+      doc.gsub!(/(table:formula=[^<>]*date-value=").*?"/, '\1_\2"')
+      z.get_output_stream('content.xml') { |f|
+        f.write(doc)
+      }
+      z.commit
+    }
+
+    if ConfigBase.openprint_simul == %w(false)
+      Docsplit.extract_pdf tmp_file, :output => '/tmp'
+      #FileUtils::cp( tmp_file, pdf_file )
+      dputs(5) { 'Finished docsplit' }
+    else
+      FileUtils::cp(tmp_file, pdf_file)
+    end
+    @dir and FileUtils::cp(pdf_file, @dir)
+    pdf_file
+  end
+
+  def print(fields = [], counter = nil, name = nil)
+    file = make_pdf(fields, counter, name)
+    print_file(file)
+  end
+
+  def print_join(files, outfile = nil)
+    outfile ||= files.first.sub(/.pdf$/, '-joined.pdf')
+    OpenPrint.pdf_join(files, outfile)
+    print_file(outfile)
+  end
+
+  # Input: 1..n files with 2 pages, front and back
+  # Output: one 2x2-nup PDF front
+  #         one 2x2-nup PDF back
+  #         to be printed "long edge duplex"
+  def self.pdf_nup_duplex(files, base = nil)
+    Dir.mktmpdir { |dir|
+      files.class == Array or files = [files]
+      allpages = "#{dir}/allpages.pdf"
+      cmd = "pdfjam --quiet --landscape --outfile #{allpages} " +
+          files.join(" '1,2' ") + " '1,2,{},{}' "
+      dputs(3) { "Running allpages-command #{cmd}" }
+      %x[ #{cmd} ]
+
+      pages_all = ((files.count + 1) & ~1).times
+      documents = {:front => pages_all.collect { |i| (i ^ 1) * 2 + 1 }.join(','),
+                   :back => pages_all.collect { |i| i * 2 + 2 }.join(',')}
+
+      base ||= File.basename files.first, '.pdf'
+      documents.collect { |suffix, pages|
+        pages_file = "/tmp/#{base}-#{suffix}.pdf"
+        cmd = 'pdfnup --quiet --landscape --nup 2x2 ' +
+            "#{allpages} #{pages} --outfile #{pages_file}"
+
+        dputs(3) { "Running pdfnup-command #{cmd}" }
+        %x[ #{cmd} ]
+        pages_file
+      }
+    }
+  end
+
+  # Input: 1..n files
+  # Output: one PDF-file
+  def self.pdf_join(files, outfile)
+    files.class == Array or files = [files]
+    System.run_bool "pdfjam --quiet --landscape --outfile #{outfile} #{files.join(' ')}"
+  end
+end
+
+module PrintButton
+  attr_reader :printer_buttons
+
+  def call_lpstat(ip)
+    if ConfigBase.use_printing.to_s == 'true'
+      %x( which lpstat >/dev/null 2>&1 && lpstat -h #{ip}:631 -a 2>/dev/null |
+          sed -e "s/ .*//" ).split
+    else
+      []
+    end
+  end
+
+  def get_remote_printers(ip)
+    if ip.match(ConfigBase.openprint_search)
+      dputs(2) { "Getting printers for #{ip}" }
+      call_lpstat(ip)
+    else
+      dputs(3) { "Not getting remote for #{ip}" }
+      []
+    end
+  end
+
+  def get_server_printers
+    call_lpstat('localhost').collect { |p|
+      "server #{p}"
+    } + %w( PDF )
+  end
+
+  def show_print(*buttons)
+    dputs(3) { "show_print with #{buttons.inspect}" }
+    if not instance_variable_defined? :@printer_buttons
+      @printer_buttons = []
+    end
+    print_name = nil
+    buttons.to_a.each { |b|
+      dputs(4) { "Doing #{b.inspect}" }
+      if b.to_s =~ /^print/
+        show_split_button b, get_server_printers
+        print_name = b.to_sym
+      else
+        show_button b
+      end
+    }
+    if not print_name
+      show_split_button :print, get_server_printers
+      print_name = :print
+    end
+    @printer_buttons.push print_name
+  end
+
+  def stat_printer(session, button)
+    stat_name = "#{self.name}:#{button}:#{session.owner.login_name}"
+    stat = Statics.get(stat_name)
+    dputs(3) { "Getting printer #{stat_name} == #{stat.data_str}" }
+    if stat.data_str == ''
+      stat.data_str = get_server_printers.first
+    end
+    stat
+  end
+
+  def cmd_printer(session, button)
+    cmd = nil
+    pn = stat_printer(session, button).data_str
+    remote = session.client_ip
+    dputs(3) { "Found printer #{pn} with remote #{remote}" }
+    if pn != 'PDF'
+      if get_server_printers.index(pn)
+        cmd = "lp -o media=a4 -o fitplot -d #{pn.sub(/^server /, '')}"
+      elsif get_remote_printers(remote).index(pn)
+        cmd = "lp -o media=a4 -o fitplot -h #{remote}:631 -d #{pn}"
+      end
+    end
+    dputs(3) { "Command will be #{cmd}" }
+    cmd
+  end
+
+  def send_printer(session, button, file)
+    if cmd = cmd_printer(session, button)
+      %x[ #{cmd} #{file} ]
+      stat_printer(session, button).data_str
+    else
+      return nil
+    end
+  end
+
+  def reply_print(session)
+    #dputs_func
+    ret = []
+    @printer_buttons.each { |pb|
+      p = stat_printer(session, pb)
+      dputs(4) { "#{pb}-#{p.inspect}" }
+      value = "#{GetText._(pb.to_s)} #{p.data_str}"
+      if session.web_req && ip = session.client_ip
+        #dputs(4) { "#{session.web_req.inspect} - #{ip.inspect}" }
+        # We're not looking for CUPS on the localhost, neither on Windows
+        if ip =~ /(::1|localhost|127.0.0.1)/ or
+            session.web_req.header['user_agent'] =~ /Windows/
+          dputs(3) { "Not looking for cups on #{ip} - #{session.web_req.header['user_agent']}" }
+        else
+          value = [value] + get_server_printers + get_remote_printers(ip)
+        end
+      end
+      ret += reply(:update, pb => value)
+    }
+    dputs(4) { "#{ret.inspect}" }
+    ret
+  end
+
+  def rpc_print(session, name, data)
+    #dputs_func
+    dputs(4) { "Printing button #{name} with #{data.inspect}" }
+    if data and data['menu'] and data['menu'].length > 0
+      stat_printer(session, name).data_str = data['menu']
+    end
+    reply_print(session)
+  end
+
+  def send_printer_reply(session, button, data, file)
+    rpc_print(session, button, data) +
+        reply(:window_show, :print_status) +
+        reply(:update, :status =>
+                         if printer = send_printer(session, button, file)
+                           "Printed to #{printer}"
+                         else
+                           "<a href='#{file}' target='other'>#{file}</a>"
+                         end)
+  end
+
+  def window_print_status
+    gui_window :print_status do
+      gui_vbox :nogroup do
+        show_html :status
+        show_button :close
+      end
+    end
+  end
+end

data/lib/qooxview/helpers/permission.rb

@@ -0,0 +1,146 @@
+#
+# Defines which views and which blocks of that view are available
+# Each user can have different Permissions, which can be
+# recursive as well.
+#
+# A permission is either
+# - an action, which is given as a ViewName.Block.Label syntax
+# - a permission-name, which is resolved recursively
+#
+# Every "name" has a permission to
+# - view: that is, display things
+# - change: that is, modify the parameters
+# - allow: that is, add permissions to other people
+
+class Permission
+  
+  def self.clear
+    @@view = {}
+    @@parent = {}
+    @@sessions = {}
+  end
+
+  self.clear
+  
+  def self.list
+    return @@view.keys
+  end
+
+  def self.add( name, view, parent = '' )
+    @@view[ name.to_s ] = view.split(',')
+    @@parent[ name.to_s ] = parent.split(',')
+  end
+  
+  def self.views( permissions )
+    #dputs_func
+    dputs(5){"Permissions: #{permissions.inspect}"}
+    dputs(5){"Views: #{@@view.inspect}"}
+    [permissions].flatten.collect{|p|
+      ret = @@view[p.to_s]
+      @@parent[p.to_s] and ret += @@parent[p.to_s].collect{|a| self.views(a) }
+      if not ret 
+        ret = []
+      end
+      dputs(5){"Having #{ret.inspect}"}
+      ret
+    }.flatten.sort.uniq
+  end
+
+  def self.session_add( session, perm )
+    dputs( 0 ){ "Deprecated - #{caller.inspect}" }
+    exit
+    #    dputs( 4 ){ "Adding permission for session #{session}: #{perm}" }
+    #    @@sessions[session.to_s] = perm
+  end
+
+  def self.session_remove( session )
+    dputs( 0 ){ "Deprecated - #{caller.inspect}" }
+    exit
+    #    @@sessions[session.to_s] = nil
+  end
+
+  def self.getViewParent( view )
+    @@view[view].to_a.collect{|c| "view:#{c}"} +
+      @@parent[view].to_a.collect{|c| "name:#{c}"}
+  end
+
+  def self.can( session, view )
+    dputs( 0 ){ "Deprecated - #{caller.inspect}" }
+    exit
+    # If the list is not initialized, then everybody can do everything!
+    if list.size == 0
+      return true
+    end
+
+    dputs( 4 ){ "@@sessions is #{@@sessions.inspect}" }
+    permission = @@sessions[session.to_s]
+    if not permission or permission.length == 0
+      permission = 'default'
+    end
+
+    self.can_view( permission, view )
+  end
+
+  def self.can_view( permission, view )
+    action = view.to_s.gsub( /^View\./, '' )
+    dputs( 4 ){ "Does #{permission.inspect} allow to do #{action} knowing #{@@view.inspect} and #{@@parent.inspect}" }
+    if not permission or permission.length == 0
+      permission = %w( default )
+    end
+
+    permission.to_a.each{|p|
+      perm_list = self.getViewParent( p )
+      dputs( 5 ){ "p is #{p} and perm_list is #{perm_list.inspect}" }
+      perm_list.each{|pl|
+        type, data = pl.split(':')
+        dputs( 5 ){ "view = #{type} and data = #{data}" }
+        case type
+        when 'name'
+          dputs( 5 ){ "Pushing #{self.getViewParent(data)}" }
+          perm_list.push( *self.getViewParent( data ) )
+        when 'view'
+          if data
+            dputs( 5 ){ "Searching #{action} - #{data.tab_name} for #{data} - #{action.class}" }
+            if action =~ /^#{data}$/ or action =~ /^#{data.tab_name}Tabs$/
+              dputs( 3 ){ "#{action} is allowed" }
+              return true
+            end
+          end
+        end
+      }
+    }
+
+    dputs( 3 ){ "#{action} is NOT allowed" }
+    return false
+  end
+
+  def self.has_role( permission, role )
+    permission.to_a.each{|perm|
+      dputs(4){"Testing #{perm} on #{role}"}
+      return true if role.to_s =~ /^#{perm}$/
+      @@parent[perm] and @@parent[perm].each{|par|
+        dputs(4){"Testing parent #{par} on #{role}"}
+        return true if par == role.to_s || self.has_role( par, role )
+      }
+    }
+    dputs(4){"Nothing found for #{permission.inspect} on #{role}"}
+    return false
+  end
+
+  # Get session
+  def self.get_session( data )
+    dputs( 0 ){ "Deprecated - #{caller.inspect}" }
+    exit
+
+    if data[0] =~ /^session_id:/
+      return data[0].gsub(/^session_id:/, '' )
+    else
+      return nil
+    end
+  end
+
+  # Try to find out what the permissions are, should be changed!
+  def self.which( *data )
+    return ''
+  end
+end

data/lib/qooxview/helpers/qoox_parser.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'gettext'
+
+include GetText
+
+module QooxParser
+  module_function
+  # If the file is the target of your parser, then return true, otherwise false.
+  def target?(file)
+    File.extname(file) == ".rb"
+  end
+
+  def parse(file)
+    ary = []
+    File.open( file ){|f|
+      line = 0
+      f.readlines.each{|l|
+        line += 1
+        if l =~ /^\s*value_[^\s]+\s+[^=]/ or l =~ /^\s*show_[^\s]+\s+[^=]/ or
+            l =~ /^\s*vtlp_list\s+[^=]/
+          case l
+          when /(value_block|show_block)/
+          when /(show_button|show_print)/
+            buttons = l.sub( /^[^:]*:/, '' ).gsub( /:/, '' ).chop.split( /,\s*/ )
+            buttons.each{|b|
+              po = POEntry.new(:normal)
+              po.msgid = b
+              po.references = [ "#{file}:#{line}" ]
+              po.add_comment( "Comes from file #{file} and line is #{l}" )
+              ary << po
+            }
+          else
+            po = POEntry.new(:normal)
+            po.msgid = l.sub( /^[^:]*:/, '' ).sub( /,.*/, '' ).chop
+            po.references = [ "#{file}:#{line}" ]
+            po.add_comment( "Comes from file #{file} and line is #{l}" )
+            ary << po
+          end
+        elsif l =~ /<\s*View\s*$/
+          po = POEntry.new(:normal)
+          po.msgid = l.sub( /^\s*class\s*/, '' ).sub( /\s*<.*$/, '' ).chop
+          po.references = [ "#{file}:#{line}" ]
+          po.add_comment( "Comes from file #{file} and line is #{l}" )
+          ary << po            
+        end
+      }
+    }
+    return ary
+  end
+
+end
+
+# Add this parser to GetText::RGetText
+GetText::Tools::XGetText.add_parser(QooxParser)

data/lib/qooxview/helpers/session.rb

@@ -0,0 +1,68 @@
+=begin
+ This class represents the actual session and holds the following
+ information:
+ 
+ - "entity_name" - chosen entities
+ - "id" - the actual id of the session
+ - "permissions" - instance of Permission
+ - "owner" - who called the session
+=end
+
+class Sessions < Entities
+  def setup_data
+    value_entity_person :owner, :drop, :full_name
+    value_str :sid
+    value_str :s_data
+    value_str :last_seen
+  end
+
+  # Adds a person with a session.
+  def create(owner = nil, sid = nil)
+    if !sid
+      sid = rand
+    end
+
+    if owner
+      if owner.session_id and old = match_by_sid(owner.session_id)
+        old.delete
+      end
+
+      owner.session_id = sid.to_s
+    end
+
+    s = super(owner: owner, sid: sid.to_s, s_data: {}, last_seen: Time.now.to_i)
+    s.web_req = nil
+    s.client_ip = nil
+    return s
+  end
+
+  def loaded
+    before = @data.length
+    # Reject all sessions that never got opened and those who are older than one day
+    @data.delete_if { |k, v|
+      !v._owner || (v._last_seen && Time.now.to_i - v._last_seen.to_i > 86_400)
+    }
+    dputs(3) { "Cleaning up: from #{before} to #{@data.length}" }
+  end
+
+end
+
+class Session < Entity
+  attr_accessor :web_req, :client_ip
+
+  def setup_instance
+    @web_req = nil
+    @client_ip = nil
+    self.s_data ||= {}
+  end
+
+  def can_view(v)
+    dputs(3) { "Owner is #{owner.inspect}" }
+    perms = owner ? owner.permissions : nil
+    return Permission.can_view(perms, v)
+  end
+
+  def close
+    self.delete
+  end
+end

data/lib/qooxview/helpers/static.rb

@@ -0,0 +1,23 @@
+class Statics < Entities
+  def setup_data
+    value_str :view_name
+    value_str :data_str
+  end
+
+  def get(name)
+    match_by_view_name(name) or
+        create(:view_name => name, :data_str => '')
+  end
+
+  def get_hash(name)
+    s = Statics.get(name)
+    s.data_str.length == 0 and
+        s.data_str = {}
+    s.data_str
+  end
+end
+
+# This way Statics is instantiated immediately, instead of
+# any time later when calling QooxView.init
+RPCQooxdooService.add_prime_service(Statics,
+                                    'Entities.Statics')

data/lib/qooxview/helpers/upload_files.rb

@@ -0,0 +1,27 @@
+# This works togehter with UploadMgr to retrieve files.
+require 'cgi'
+
+class UploadFiles < RPCQooxdooPath
+  @@files = []
+  def self.parse_req( req )
+    dputs( 4 ){ "UploadFiles: #{req.inspect}" }
+    path = ConfigBase.upload_files
+    filename = CGI.unescape( req.header['x-file-name'][0] || "unknown" )
+    filename = self.escape_chars( filename )
+    dputs(4){"Writing to #{filename.inspect} in #{path.inspect}"}
+    name = "#{path}/#{filename}"
+    dputs(2){"Writing to #{name}"}
+    File.open( "#{name}", "w:ASCII-8BIT" ){|f|
+      f << req.query["file"]
+    }
+    @@files.push name
+  end
+  
+  def self.get_files
+    @@files
+  end
+  
+  def self.escape_chars( name )
+    name.gsub(/[^a-zA-Z0-9_\.-]/, '_')
+  end
+end