watobo 0.9.11 → 0.9.12

data/CHANGELOG

@@ -1,3 +1,15 @@
+= Version 0.9.12
+== NEW
+* [Module] Siebel Checks: Enumeration of default apps and files, e.g. base.txt
+* [Module] PassiveCheck filtering Domino DB names
+* [GUI] added De-Select-All buttons to scan policy
+* [GUI] finding details menu available at finding-class level
+
+== Fixes
+* crash when pasting data (Linux)
+* crash on starting full scan dialog
+* minor issue when adding a new db-path to catalog scanner plugin
+
 = Version 0.9.11
 == NEW
 * [FileFinder] pimped the interface, added save-settings

data/bin/watobo

@@ -1,2 +1,10 @@
 #!/bin/ruby
-puts "Please use the command watobo_gui.rb to start watobo."
+# this is just a little wrapper to start watobo with another command than watobo_gui.rb
+if $0 == __FILE__
+  inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) # this is the same as rubygems would do
+  $: << inc_path
+end
+
+path = File.dirname(File.expand_path(__FILE__))
+require File.join(path, "watobo_gui")
+

data/lib/watobo/adapters/data_store.rb

@@ -20,7 +20,13 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 # .
 module Watobo
-  class DataStore  
+  class DataStore
+    
+    @engine = nil
+    
+    def self.engine
+      @engine
+    end  
       
     def self.acquire(project_name, session_name)
       a = Watobo::Conf::Datastore.adapter
@@ -30,9 +36,16 @@ module Watobo
       else
         nil
       end
+      @engine = store
       store
     end
     
         
   end
+  
+  def self.log(message, prefs={})
+    if DataStore.engine.respond_to? :logger
+      DataStore.engine.logger message, prefs
+    end
+  end
 end

data/lib/watobo/adapters/file/file_store.rb

@@ -149,6 +149,10 @@ module Watobo
       wsp = Watobo.workspace_path
       return false unless File.exist? wsp
       puts "* using workspace path: #{wsp}" if $DEBUG
+      
+      @log_file = nil
+      @log_lock = Mutex.new
+      
       @project_path = File.join(wsp, project_name)
       unless File.exist? @project_path
         puts "* create project path: #{@project_path}" if $DEBUG
@@ -193,6 +197,8 @@ module Watobo
           end
         end
       end
+      
+      @log_file = File.join(@log_path, session_name + ".log")
 
     #     @chat_files = get_file_list(@conversation_path, "*-chat")
     #     @finding_files = get_file_list(@findings_path, "*-finding")
@@ -248,6 +254,33 @@ module Watobo
       s = Watobo::Utils.load_settings(project_file)
       s
 
+    end
+    
+    def logger( message, prefs = {} )
+      opts = { :sender => "unknown", :level => Watobo::Constants::LOG_INFO }
+      opts.update prefs
+      return false if @log_file.nil?
+      begin
+         t = Time.now
+        now = t.strftime("%m/%d/%Y @ %H:%M:%S")
+        log_message = [ now ]
+        log_message << "#{opts[:sender]}"
+        if message.is_a? Array
+          log_message << message.join("\n| ")
+          log_message << "\n-"
+        else        
+          log_message << message
+        end
+        @log_lock.synchronize do
+          File.open(@log_file,"a") do |lfh|
+            lfh.puts log_message.join("|")
+          end
+        end
+      rescue => bang
+        puts bang
+      end
+      
+      
     end
 
     private

data/lib/watobo/core/active_check.rb

@@ -55,10 +55,11 @@ module Watobo
         id_string << new_details[:title]  if new_details[:title]
 
         if id_string == '' then
-        id_string = rand(10000)
+        id_string = (Time.now.to_i + rand(10000)).to_s
         end
         #
         new_details[:fid] = Digest::MD5.hexdigest(id_string)
+        puts new_details[:fid] if $DEBUG
 
         new_details[:module] = self.class.to_s
         # new_details[:module] = Module.nesting[]
@@ -67,7 +68,7 @@ module Watobo
         new_details.delete(:chat)
 
         new_finding = Watobo::Finding.new(request, response, new_details)
-        #  puts new_finding
+      #  puts new_finding
         notify(:new_finding, new_finding)
       }
     end

data/lib/watobo/core/project.rb

@@ -640,7 +640,7 @@ module Watobo
           :save_finding => true
         }
         options.update opts
-        #  puts "* add finding #{finding.details[:fid]}" if $DEBUG
+        puts "[Project] add finding #{finding.details[:fid]}" if $DEBUG
 
         @findings_count ||= Hash.new
         @findings_count[finding.details[:class]] = 0 unless @findings_count.has_key? finding.details[:class]
@@ -814,7 +814,11 @@ module Watobo
       #      @active_checks = @settings[:active_checks]
       @settings[:active_checks].each do |am|
         ac = am.new(self)
-        ac.subscribe(:new_finding){ |nf| addFinding(nf) }
+      #  puts "subscribe to #{ac.class}"
+        ac.subscribe(:new_finding){ |nf| 
+       #   puts "[subscribe] new_finding"
+          addFinding(nf)
+           }
         @active_checks << ac
       end
 

data/lib/watobo/core/scanner.rb

@@ -27,6 +27,7 @@ module Watobo
     attr :progress
 
     include Watobo::Constants
+    
     def subscribe(event, &callback)
       (@event_dispatcher_listeners[event] ||= []) << callback
     end
@@ -264,11 +265,16 @@ module Watobo
           check.reset()
           if @prefs[:online_check] == false or siteAlive?(chat) then
             @check_list << Thread.new(check, chat, check_prefs){|m, c, p|
+              begin
               m_name = m.class.to_s.gsub(/.*::/,'')
               notify(:module_started, m_name)
               m.run_checks(c,p)
+              rescue => bang
+                puts bang
+                puts bang.backtrace
+              end
               notify(:logger, LOG_INFO, "finished checks: #{m.class} on chat #{c.id}")
-              notify(:module_finished, m_name)
+              notify(:module_finished, m)
             }
           end
         end

data/lib/watobo/core/session.rb

@@ -37,6 +37,8 @@ include Watobo::Constants
       @@login_in_progress = false
       def subscribe(event, &callback)
         (@event_dispatcher_listeners[event] ||= []) << callback
+        puts "#{self} : #subscriptions -> #{event} :" + @event_dispatcher_listeners[event].length.to_s
+        puts @event_dispatcher_listeners[event].first
       end
 
       def clearEvents(event)
@@ -46,7 +48,7 @@ include Watobo::Constants
 
       def notify(event, *args)
         if @event_dispatcher_listeners[event]
-           puts "NOTIFY: #{self}(:#{event}) [#{@event_dispatcher_listeners[event].length}]" if $DEBUG
+          # puts "NOTIFY: #{self}(:#{event}) [#{@event_dispatcher_listeners[event].length}]" if $DEBUG
           @event_dispatcher_listeners[event].each do |m|           
             m.call(*args) if m.respond_to? :call
           end

data/lib/watobo/gui/checkboxtree.rb

@@ -19,20 +19,71 @@
 # along with WATOBO; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 # .
+if $0 == __FILE__
+  inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+  $: << inc_path
+
+  require 'watobo'
+  require 'watobo/gui'
+
+  require 'fox16'
+
+  include Fox
+  include Watobo::Constants
+
+end
+
 module Watobo
   module Gui
     class CheckBoxTreeItem < FXTreeItem
       attr_accessor :checked
-      
+
       include Watobo::Gui::Icons
-      def initialize(text, checked, data)
-        @checked = checked
-        icon = ICON_CB_CHECKED
-        icon = ICON_CB_UNCHECKED if not checked
-        super(text, icon, icon, data)
+      def check
+        begin
+          @checked = true
+          self.setOpenIcon(ICON_CB_CHECKED)
+          self.setClosedIcon(ICON_CB_CHECKED)
+          # opened = true
+        rescue => bang
+          puts "!!!ERROR: could not uncheck item"
+        end
+      end
+
+      def uncheck
+        begin
+          @checked = false
+          self.setOpenIcon(ICON_CB_UNCHECKED)
+          self.setClosedIcon(ICON_CB_UNCHECKED)
+          #opened = false
+        rescue => bang
+          puts "!!!ERROR: could not uncheck item"
+        end
+      end
+
+      def toggle
+        if @checked
+          uncheck
+        else
+          check
+        end
+      end
+
+      def initialize(item_text, item_status, item_data)
+        super item_text
+        @checked = item_status
+        #icon = ICON_CB_CHECKED
+        #icon = ICON_CB_UNCHECKED if not status
+        #super(text, icon, icon, data)
+        #   data = item_data
+        if @checked
+          check
+        else
+          uncheck
+        end
       end
     end
-    
+
     class CheckBoxTreeList < FXTreeList
       include Watobo::Gui::Icons
       #------------------------------
@@ -42,51 +93,52 @@ module Watobo
       #                   :name => element_name, number of subtrees controlled via pipe-char, e.g. <level1>|<level2>|item
       #                   :enabled => true|false,
       #                   :data => object|string|...
-      #                   }, {..} ] 
-      def createTree(elements)
+      #                   }, {..} ]
+      def elements=(elements)
         self.clearItems()
         elements.each do |e|
-          
-          # puts icon.class.to_s
+
+        # puts icon.class.to_s
           node = nil
           levels = e[:name].split('|')
-          puts "Processing: #{e[:name]} > #{e[:data].class}" if $DEBUG
-          levels.each do |l|
-            
+        #  puts "Processing: #{e[:name]} > #{e[:data].class}" if $DEBUG
+          levels.each_with_index do |l,i|
+            #puts "#{l} - #{l.class}"
             item = self.findItem(l, node, SEARCH_FORWARD|SEARCH_IGNORECASE)
-            
+
             if item.nil? then
-              new_item = CheckBoxTreeItem.new(l, e[:enabled], nil)
-              # item = self.appendItem(node, l, ICON_CB_CHECKED, ICON_CB_CHECKED) 
-              item = self.appendItem(node, new_item)
-              if e[:enabled] then
-                self.openItem(item, false)
-              else
-                self.closeItem(item, false)
-              end
+              # new_item = CheckBoxTreeItem.new(l, e[:enabled], nil)
+              new_item = CheckBoxTreeItem.new(l, e[:enabled], :none)
+            # item = self.appendItem(node, l, ICON_CB_CHECKED, ICON_CB_CHECKED)
+            item = self.appendItem(node, new_item)
+            #  if e[:enabled] then
+            #    self.openItem(item, false)
+            #  else
+            #    self.closeItem(item, false)
+            #  end
             end
             node = item
-            if l == levels.last then
+            if i == levels.length-1 then
               self.setItemData(item, e[:data])
               updateParent(item)
             end
-            
+
           end
         end
       end
-      
+
       def updateParent(child)
         parent = child.parent
         # count enabled childs
         return false if parent.nil?
         ec = 0
         parent.each do |item|
-          #data = self.getItemData(item)
-          #ec += 1 if data[:enabled]
+        #data = self.getItemData(item)
+        #ec += 1 if data[:enabled]
           ec += 1 if item.checked
         end
         if ec == 0 then
-          
+
           # puts "no childs selected"
           icon = ICON_CB_UNCHECKED
           self.setItemData(parent, :none)
@@ -95,130 +147,220 @@ module Watobo
           icon = ICON_CB_CHECKED_ORANGE
           self.setItemData(parent, :partly)
         else
-          
-          # puts "all childs have been selected"
+
+        # puts "all childs have been selected"
           icon =   ICON_CB_CHECKED
           self.setItemData(parent, :all)
         end
         self.setItemOpenIcon(parent, icon)
         self.setItemClosedIcon(parent, icon)
       end
-      
-      def toggleState(item)
-        #  data = self.getItemData(item)
-        #  if data[:enabled] then
-        if item.checked then
-          uncheckItem(item)
-        else
-          checkItem(item)
-        end
-      end
-      
-      def uncheckItem(item)
-        begin
-          #data = self.getItemData(item)
-          #data[:enabled]= false
-          item.checked = false        
-          self.setItemOpenIcon(item, ICON_CB_UNCHECKED)
-          self.setItemClosedIcon(item, ICON_CB_UNCHECKED)
-          #puts item.data.class
-        rescue => bang
-          puts "!!!ERROR: could not uncheck item"
-        end
-        
-      end
-      
-      
-      def getCheckedData(item = nil, data = nil)
+
+     def getCheckedData(item = nil, data = nil)
         data = [] if !data
         item = self if !item
         item.each do |c|
-           getCheckedData(c, data) if c.numChildren > 0
-           data.push c.data if self.itemLeaf?(c) and c.checked
-       end
-       data
+          getCheckedData(c, data) if c.numChildren > 0
+          data.push c.data if self.itemLeaf?(c) and c.checked
+        end
+        data
       end
-      
-      def checkItem(item)
-        begin
-          #data = self.getItemData(item)
-          #data[:enabled] = true
-          item.checked = true
-          self.setItemClosedIcon(item, ICON_CB_CHECKED)
-          self.setItemOpenIcon(item, ICON_CB_CHECKED)
-          # puts item.data.class
-        rescue => bang
-          puts "!!!ERROR: could not uncheck item"
+
+      def checkAll
+        self.each do |r|
+          r.check
+          setItemData(r,:all)
+          r.each do |c|
+            c.check
+          end
+          self.update
+        # checkAllChildren(r)
+        #   openItem(child, true)
         end
       end
-      
+
+      def uncheckAll
+        self.each do |r|
+        # uncheckItem(r)
+          r.uncheck
+          setItemData(r,:none)
+          r.each do |c|
+            c.uncheck
+          end
+          #uncheckAllChildren(r)
+          self.update
+        end
+      end
+
+     
       def uncheckAllChildren(parent)
         parent.each do |child|
-          uncheckItem(child)
+        #uncheckItem(child)
+          child.uncheck
         end
       end
-      
+
       def checkAllChildren(parent)
         parent.each do |child|
-          checkItem(child)
+        #checkItem(child)
+          child.check
+
         end
       end
-      
+
       def initialize(parent)
-        
+
         @parent = parent
         super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|
-              TREELIST_SHOWS_LINES|
-              TREELIST_SHOWS_BOXES|
-              TREELIST_ROOT_BOXES|
-              #TREELIST_EXTENDEDSELECT|
-              TREELIST_MULTIPLESELECT
+        TREELIST_SHOWS_LINES|
+        TREELIST_SHOWS_BOXES|
+        TREELIST_ROOT_BOXES|
+        #TREELIST_EXTENDEDSELECT|
+        TREELIST_MULTIPLESELECT
         )
         #LAYOUT_TOP|LAYOUT_RIGHT|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|TREELIST_ROOT_BOXES|TREELIST_EXTENDEDSELECT
-        
+
         self.connect(SEL_COMMAND) do |sender, sel, item|
           if $DEBUG
-           puts "Selected Item: #{item}"
+            puts "Selected Item: #{item}"
             if item.parent
               puts "Member Of: #{item.parent}"
-             puts "Has Brothers: #{item.parent.numChildren}"
+              puts "Has Brothers: #{item.parent.numChildren}"
             end
           end
+
           if self.itemLeaf?(item) then
-            toggleState(item)
+            #toggleState(item)
+            item.toggle
             updateParent(item)
           else
             data = self.getItemData(item)
+
             new_state = case data
-              when :partly
+            when :partly
               #  puts data
               icon = ICON_CB_UNCHECKED
               uncheckAllChildren(item)
               :none
-              when :none
+            when :none
               #  puts data
               icon = ICON_CB_CHECKED
               checkAllChildren(item)
               :all
-              when :all
+            when :all
               # puts data
               icon = ICON_CB_UNCHECKED
               uncheckAllChildren(item)
               :none
             end
-            
-            self.setItemData(item, new_state)
-            self.setItemClosedIcon(item, icon)
-            self.setItemOpenIcon(item, icon)
+
+          self.setItemData(item, new_state)
+          self.setItemClosedIcon(item, icon)
+          self.setItemOpenIcon(item, icon)
           end
-          
+
           self.killSelection()
-        end  
-        
-        
-        
+        end
+
       end
     end
-    #--
+  #--
   end
 end
+
+##########################
+
+if $0 == __FILE__
+  module Watobo
+    module Gui
+
+      @application ||= FXApp.new('LayoutTester', 'FoxTest')
+      class TestGui < FXMainWindow
+        class TreeDlg < FXDialogBox
+
+          include Responder
+          def initialize(parent, project=nil, prefs={} )
+            super(parent, "CheckBox Dialog", DECOR_ALL, :width => 300, :height => 400)
+            FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept)
+            frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE)
+            elements = []
+            num_root_nodes = 4
+            max_child_nodes = 4
+            num_root_nodes.times do |ri|
+              max_child_nodes.times do |si|
+                name = "root#{ri}|sub#{si}"
+                data = name + "-data"
+                e = { :name => name, :enabled => false, :data => data }
+                elements << e
+              end
+            end
+            @cbtree = CheckBoxTreeList.new(frame)
+            @cbtree.elements = elements
+
+          end
+          private
+
+          def onAccept(sender, sel, event)
+            puts "#{self} closed"
+
+            getApp().stopModal(self, 1)
+            self.hide()
+            return 1
+          end
+        end
+
+        def leave
+          d = @cbtree.getCheckedData
+          puts d.class
+          puts d
+          exit
+        end
+
+        def initialize(app)
+          # Call base class initializer first
+          super(app, "Test Application", :width => 800, :height => 600)
+          frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE)
+
+          elements = []
+          num_root_nodes = 4
+          max_child_nodes = 4
+          num_root_nodes.times do |ri|
+            max_child_nodes.times do |si|
+              name = "root#{ri}|sub#{si}"
+              data = name + "-data"
+              e = { :name => name, :enabled => false, :data => data }
+              elements << e
+            end
+          end
+
+          @cbtree = CheckBoxTreeList.new(frame)
+          @cbtree.elements = elements
+
+          FXButton.new(frame, "Select All",:opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT).connect(SEL_COMMAND){ @cbtree.checkAll }
+          FXButton.new(frame, "Deselect All",:opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT).connect(SEL_COMMAND){ @cbtree.uncheckAll }
+
+          FXButton.new(frame, "Open TreeDialog",:opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT).connect(SEL_COMMAND){
+            dlg = TreeDlg.new(self)
+            if dlg.execute != 0 then
+              puts "* Dialog Finished"
+            else
+              puts "Dialog Canceled"
+            end
+          }
+
+          FXButton.new(frame, "Exit",:opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT).connect(SEL_COMMAND){ leave }
+        end
+
+        def create
+          super                  # Create the windows
+          show(PLACEMENT_SCREEN) # Make the main window appear
+        end
+      end
+      #  application = FXApp.new('LayoutTester', 'FoxTest')
+      TestGui.new(@application)
+      @application.create
+      @application.run
+
+    end
+  end
+end