watobo 0.9.9.pre3 → 0.9.9

data/lib/watobo/gui/rewrite_rules_dialog.rb

@@ -0,0 +1,394 @@
+# .
+# rewrite_rules_dialog.rb
+# 
+# Copyright 2012 by siberas, http://www.siberas.de
+# 
+# This file is part of WATOBO (Web Application Tool Box)
+#        http://watobo.sourceforge.com
+# 
+# WATOBO is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation version 2 of the License.
+# 
+# WATOBO is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with WATOBO; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# .
+module Watobo
+  module Gui
+    class RulesTableCtrl < FXHorizontalFrame
+      attr_accessor :target
+      
+      def initialize(owner,target = nil, opts)
+        @target = target
+        super owner, opts
+        matrix = FXMatrix.new(self, 4, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+        
+        %w( Action Location Pattern Content).each do |l|
+          FXLabel.new(matrix, l)
+        end
+        
+        @actions_combo = FXComboBox.new(matrix, 10, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK)
+        #@filterCombo.width =200
+
+        @actions_combo.numVisible = 0
+        @actions_combo.numColumns = 10
+        @actions_combo.editable = false
+        @actions_combo.connect(SEL_COMMAND){}
+        
+        @locations_combo = FXComboBox.new(matrix, 10, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK)
+        #@filterCombo.width =200
+
+        @locations_combo.numVisible = 0
+        @locations_combo.numColumns = 10
+        @locations_combo.editable = false
+        @locations_combo.connect(SEL_COMMAND){}
+        
+        @pattern_txt = FXTextField.new(matrix, 20, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN)
+         @content_txt = FXTextField.new(matrix, 20, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN)
+         
+         frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0)
+         top_btn_frame = FXHorizontalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0)
+      
+        @del_btn = FXButton.new(top_btn_frame, "Del" ,  nil, nil)
+        @del_btn.enable
+        @del_btn.connect(SEL_COMMAND){ delete_rule }
+
+     #   @edit_btn = FXButton.new(top_btn_frame, "Edit ..." ,  nil, nil)
+     #   @edit_btn.enable
+     #   @edit_btn.connect(SEL_COMMAND){ delete_rule }
+
+        @up_btn = FXButton.new(top_btn_frame, "Up" ,  nil, nil)
+        @up_btn.enable
+
+        @down_btn = FXButton.new(top_btn_frame, "Down" ,  nil, nil)
+        @down_btn.enable
+        
+         @filter_btn = FXButton.new(top_btn_frame, "Filter" ,  nil, nil)
+        @filter_btn.enable
+        @filter_btn.connect(SEL_COMMAND){ open_filter_dialog }
+        
+        
+        add_btn_frame = FXHorizontalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0)
+        @add_btn = FXButton.new(add_btn_frame, "Add ..." ,  nil, nil, )
+        @add_btn.enable
+        @add_btn.connect(SEL_COMMAND){ add_rule }
+
+      end
+
+      private
+
+      def init_handlers()
+
+      end
+
+      def clear_actions
+        @actions_combo.clearItems()
+      end
+
+      def add_action(a)
+        @actions_combo.appendItem(a.to_s, a)
+        @actions_combo.numVisible = @actions_combo.numItems
+      end
+
+      def add_location(l)
+        @locations_combo.appendItem(l.to_s, l)
+         @locations_combo.numVisible = @locations_combo.numItems
+      end
+      
+      def delete_rule
+       @target.delete_current_row if @target.respond_to? :delete_current_row
+        
+      end
+      
+      def add_rule
+        return false if @target.nil?
+        #TODO: Add some checks if rule is ok
+         @target.add_rule Watobo::Interceptor::CarverRule.new(:action => @actions_combo.getItemData(@actions_combo.currentItem), 
+                                                              :location => @locations_combo.getItemData(@locations_combo.currentItem),
+                                                              :pattern => @pattern_txt.text, 
+                                                              :content => @content_txt.text, 
+                                                              :filter => nil
+                                                              )
+      end
+      
+      def open_filter_dialog
+      
+      end
+
+    end
+    
+    class RequestRulesCtrl < RulesTableCtrl
+      def initialize(owner, target, opts)
+        super owner, target, opts
+        add_action :rewrite
+        add_action :flag
+        add_location :url
+        add_location :body
+        add_location :header
+        add_location :cookie
+        add_location :http_parm
+        
+      end
+      
+      def open_filter_dialog
+         rule = @target.current_rule
+        return false if rule.nil?
+        dlg = Watobo::Gui::RequestFilterDialog.new( self, rule )
+        if dlg.execute != 0 then
+        # TODO: Apply interceptor settings
+        rule.set_filter dlg.filter
+        @target.reset_table
+        
+        end
+      end
+    end
+    
+    class ResponseRulesCtrl < RulesTableCtrl
+      def initialize(owner, target, opts)
+        super owner, target, opts
+        add_action :rewrite
+        add_location :body
+        add_location :header
+        add_location :replace_all        
+      end
+      
+      def open_filter_dialog
+         rule = @target.current_rule
+        return false if rule.nil?
+        dlg = Watobo::Gui::ResponseFilterDialog.new( self, rule )
+        if dlg.execute != 0 then
+        # TODO: Apply interceptor settings
+        rule.set_filter dlg.filter
+        @target.reset_table
+        end
+      end
+    end
+
+    class RulesTable < FXTable
+      attr :rules
+      def add_rule(rule)
+        @rules << rule
+        add_rule_row(rule)
+      end
+      
+      def current_rule
+        return nil if self.currentRow < 0
+        return @rules[self.currentRow]
+      end
+      
+      def delete_row_by_index(index)
+        return false if index < 0
+        return false if index > self.numRows-1
+        @rules.delete_at index
+        self.clearItems
+        reset_table
+        true
+      end
+      
+      def reset_table
+        init_columns
+        
+        @rules.each do |r|
+          add_rule_row r
+        end
+        adjust_cell_width
+        self.selectRow self.currentRow if self.currentRow >= 0
+      end
+      
+      def delete_current_row
+        i = self.currentRow
+        return false if i < 0
+        delete_row_by_index i
+      end
+
+      def initialize( owner, rules=[], opts={} )
+        @event_dispatcher_listeners = Hash.new
+        parms = { :opts => TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP,
+          :padding => 2
+        }
+        parms.update opts
+
+        super(owner, parms)
+        
+        self.extend Watobo::Gui::Subscriber
+        self.setBackColor(FXRGB(255, 255, 255))
+        self.setCellColor(0, 0, FXRGB(255, 255, 255))
+        self.setCellColor(0, 1, FXRGB(255, 240, 240))
+        self.setCellColor(1, 0, FXRGB(240, 255, 240))
+        self.setCellColor(1, 1, FXRGB(240, 240, 255))
+
+        @columns=Hash.new
+        
+        @rules = []
+        @rules.concat rules
+        
+         add_column "Action", 50
+        add_column "Location", 80
+        add_column "Pattern", 80
+        add_column "Content", 80
+        add_column "Filter", 80
+
+        init_columns
+        
+        @rules.each do |r|
+          add_rule_row r
+        end
+        adjust_cell_width
+        
+        self.connect(SEL_SELECTED){|sender,sel,pos| 
+                   self.selectRow pos.row
+                 #  notify(:rule_selected, @rules[pos.row])
+                   }
+      end
+      
+      private
+      
+ def add_rule_row(rule)
+   row_index = self.getNumRows
+        self.appendRows(1)
+
+        self.rowHeader.setItemJustify(row_index, FXHeaderItem::RIGHT)
+        self.setRowText(row_index, (row_index+1).to_s)
+
+        index = @columns[:action][:order]
+        self.setItemText(row_index, index, rule.action_name)
+        self.getItem(row_index, index).justify = FXTableItem::LEFT
+
+        index = @columns[:location][:order]
+        self.setItemText(row_index, index, rule.location_name)
+        self.getItem(row_index, index).justify = FXTableItem::LEFT
+
+        index = @columns[:pattern][:order]
+        self.setItemText(row_index, index, rule.pattern_name)
+        self.getItem(row_index, index).justify = FXTableItem::LEFT
+
+        index = @columns[:content][:order]
+        self.setItemText(row_index, index, rule.content_name)
+        self.getItem(row_index, index).justify = FXTableItem::LEFT
+
+        index = @columns[:filter][:order]
+        self.setItemText(row_index, index, rule.filter_name)
+        self.getItem(row_index, index).justify = FXTableItem::LEFT
+
+
+ end
+      def add_column(name, width, order=0)
+        o = ( order == 0 ) ? @columns.length : order
+        @columns[name.downcase.to_sym] = { :name => name,
+          :width => width,
+          :order => o
+        }
+
+      end
+
+      def adjust_cell_width()
+        begin
+          self.rowHeader.width = 30
+          #self.fitColumnsToContents(0)
+          @columns.each_with_index do |v,i|
+
+            self.setColumnWidth(i, v[1][:width])
+          end
+        rescue => bang
+          puts "!!!ERROR: adjustCellWidth"
+          puts bang
+          puts bang.backtrace
+        end
+
+      end
+
+      def init_columns
+        self.setTableSize(0, @columns.length)
+        self.visibleRows = 5
+        self.visibleColumns = @columns.length
+
+        @columns.sort_by{|k,v| v[:order] }.each_with_index do |v,i|
+          self.setColumnText( i, v[1][:name] )
+        end
+
+      end
+
+    end
+
+    class RequestRulesTable < RulesTable
+      def initialize(owner, opts={})
+        super owner, opts
+        add_column "Action", 50
+        add_column "Location", 80
+        add_column "Pattern", 80
+        add_column "Content", 80
+        add_column "Filter", 80
+
+        init_columns
+        adjust_cell_width
+
+      end
+    end
+
+    class RewriteRulesDialog < FXDialogBox
+
+      include Responder
+      def request_rules
+        @request_rules_table.rules
+      end
+
+      def response_rules
+        @response_rules_table.rules
+      end
+
+      def initialize(owner, settings = {} )
+        super(owner, "Rewrite Rules", DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE, :width => 650, :height => 610)
+
+        FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept)
+
+        @main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0)
+        init_request_rules(@main_frame)
+        init_response_rules(@main_frame)
+
+        buttons_frame = FXHorizontalFrame.new(@main_frame, :opts => LAYOUT_FILL_X|LAYOUT_BOTTOM)
+        @finishButton = FXButton.new(buttons_frame, "Accept" ,  nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT)
+        @finishButton.enable
+        @finishButton.connect(SEL_COMMAND) do |sender, sel, item|
+        #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil)
+          self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil)
+        end
+
+        @cancelButton = FXButton.new(buttons_frame, "Cancel" ,
+        :target => self, :selector => FXDialogBox::ID_CANCEL,
+        :opts => BUTTON_NORMAL|LAYOUT_RIGHT)
+      end
+
+      private
+
+      def onAccept(sender, sel, event)
+
+        getApp().stopModal(self, 1)
+        self.hide()
+        return 1
+      end
+
+      def init_request_rules(owner)
+
+        gbframe = FXGroupBox.new(owner, "Request Rules", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0)
+        frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0)
+        
+        @request_rules_table = RulesTable.new(frame, Interceptor::RequestCarver.rules)       
+        @request_rules_ctrl = RequestRulesCtrl.new(gbframe, @request_rules_table, :opts => LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK)
+      end
+
+      def init_response_rules(owner)
+        gbframe = FXGroupBox.new(owner, "Response Rules", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0)
+        frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0)
+        
+        @response_rules_table = RulesTable.new(frame, Interceptor::ResponseCarver.rules)       
+        @response_rules_ctrl = ResponseRulesCtrl.new(gbframe, @response_rules_table, :opts => LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK)
+      end
+    end
+  end
+end

data/lib/watobo/gui/scanner_settings_dialog.rb

@@ -81,10 +81,11 @@ module Watobo
         end
       end
       
-      def initialize(owner, scan_settings, opts)        
+    #  def initialize(owner, scan_settings, opts)        
+      def initialize(owner, opts)
         super(owner, opts)
         
-        @settings = scan_settings
+        @settings = Watobo::Conf::Scanner.to_h
        # puts @settings[:scanlog_dir]
         scroller = FXScrollWindow.new(self, :opts => SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y)
         scroll_area = FXVerticalFrame.new(scroller, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0)
@@ -312,7 +313,9 @@ module Watobo
       
       def onAccept(sender, sel, event)
         
-        @scanner_settings = @scannerSettingsFrame.getSettings()
+        new_settings = Watobo::Conf::Scanner.to_h
+        new_settings.update @scannerSettingsFrame.getSettings()
+        Watobo::Conf::Scanner.set new_settings
         
         getApp().stopModal(self, 1)
         self.hide()
@@ -321,9 +324,9 @@ module Watobo
       
      
       
-      def initialize(owner, scanner_settings, prefs)
+      def initialize(owner, prefs)
         super(owner, "Scanner Settings", DECOR_TITLE|DECOR_BORDER, :width => 400, :height => 500)
-        @scanner_settings = scanner_settings
+       # @scanner_settings = scanner_settings
         FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept)
         
         
@@ -332,7 +335,7 @@ module Watobo
         #  puts "create scopeframe with scope:"
         # @project.scope
         # @defineScopeFrame = DefineScopeFrame.new(base_frame, @project.listSites(), YAML.load(YAML.dump(@project.scope)), prefs)
-        @scannerSettingsFrame = ScannerSettingsFrame.new(base_frame, @scanner_settings, :opts => SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+        @scannerSettingsFrame = ScannerSettingsFrame.new(base_frame, :opts => SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y)
         
         buttons_frame = FXHorizontalFrame.new(base_frame,
                                               :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP)

data/lib/watobo/gui/session_management_dialog.rb

@@ -227,8 +227,8 @@ module Watobo
         @signature_field.handle(self, FXSEL(SEL_UPDATE, 0), nil)
       end
 
-      def initialize(parent, project)
-        @project = project
+      def initialize(parent)
+        @project = Watobo.project
         @signature = FXDataTarget.new('')
 
         super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y)
@@ -251,12 +251,12 @@ module Watobo
 
         @signature_list.connect(SEL_COMMAND,method(:onSignatureClick))
 
-        if @project then
-          @project.getLogoutSignatures.each do |p|
+        
+        Watobo::Conf::Scanner.logout_signatures.each do |p|
             item = @signature_list.appendItem("#{p}")
             @signature_list.setItemData(item, p)
           end
-        end
+        
       end
     end
 
@@ -418,8 +418,8 @@ module Watobo
         end
       end
 
-      def initialize(parent, project)
-        @project = project
+      def initialize(parent)
+        @project = Watobo.project
         @pattern = FXDataTarget.new('')
 
         super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y)
@@ -466,18 +466,18 @@ module Watobo
         sunken = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0)
         @response_viewer = SidPreview.new(sunken, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y)
 
-        if @project then
-          @project.getSidPatterns.each do |p|
+        
+        Watobo::Conf::Scanner.sid_patterns.each do |p|
             item = @pattern_list.appendItem("#{p}")
             @pattern_list.setItemData(item, p)
           end
-        end
+        
       end
     end
 
     class SIDCacheFrame < FXVerticalFrame
-      def initialize(parent, project)
-        @project = project
+      def initialize(parent)
+        @project = Watobo.project
         super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y)
       #  button_frame = FXHorizontalFrame.new(self, :opts=> LAYOUT_FILL_X)
       #  refresh_btn = FXButton.new(button_frame, "Refresh")
@@ -566,8 +566,8 @@ module Watobo
         @scriptTable.addChat(chat)
       end
 
-      def initialize(parent, project)
-        @project = project
+      def initialize(parent)
+        @project = Watobo.project
         @table_filter = FXDataTarget.new('')
         @sel_row = -1
         super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y)
@@ -609,7 +609,7 @@ module Watobo
         frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED)
         @response_viewer = Watobo::Gui::SimpleTextView.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0)
 
-        if @project then
+        if @project.respond_to? :getLoginChatIds then
           @project.getLoginChatIds.each do |id|
             chat = @project.getChat(id)
             addRequest(chat)
@@ -636,8 +636,8 @@ module Watobo
         signatures = @logoutSettings.getLogoutSignatures()
       end
 
-      def initialize(owner, project)
-        @project = project
+      def initialize(owner)
+        #@project = project
         # Invoke base class initialize function first
         #  super(owner, "LoginScript Wizzard", DECOR_TITLE|DECOR_BORDER,:width=>800, :height=>600)
         super(owner, "Session Management", DECOR_ALL, :width=>800, :height=>600)
@@ -645,20 +645,28 @@ module Watobo
         main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0)
 
         tabBook = FXTabBook.new(main_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT)
+        @loginSettings = nil
+        @sidSettings = nil
+        
+        unless Watobo.project.nil?
 
         login_tab = FXTabItem.new(tabBook, "Login Script", nil)
-        @loginSettings = LoginScriptSettings.new(tabBook, @project)
+        @loginSettings = LoginScriptSettings.new(tabBook)
 
-        sid_tab = FXTabItem.new(tabBook, "Sesssion IDs", nil)
+       
+        end
+         sid_tab = FXTabItem.new(tabBook, "Sesssion IDs", nil)
         # @sidFrame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y)
-        @sidSettings = SessionIdSettings.new(tabBook, @project)
+        @sidSettings = SessionIdSettings.new(tabBook)
 
         logout_tab = FXTabItem.new(tabBook, "Logout Signatures", nil)
-        @logoutSettings = LogoutSettings.new(tabBook, @project)
+        @logoutSettings = LogoutSettings.new(tabBook)
 
+        unless Watobo.project.nil?
         sidcache_tab = FXTabItem.new(tabBook, "SID-Cache", nil)
-        SIDCacheFrame.new(tabBook, @project)
-
+        SIDCacheFrame.new(tabBook)
+        end
+        
         tabBook.connect(SEL_COMMAND) do |sender, sel, tabItem|
 
           case tabItem.to_i
@@ -666,8 +674,10 @@ module Watobo
             #  puts "Login Script Selected"
           when 1
             # puts "Session IDs Selected"
+            unless Watobo.project.nil?
             ids = getLoginScriptIds()
             @sidSettings.updateRequests(ids)
+            end
           when 2
             #   puts "Logout Selected"
           end

data/lib/watobo/gui/sites_tree.rb

@@ -99,15 +99,14 @@ module Watobo
       end
 
       def addChat(chat)
-        add_chat = true
-
-        add_chat = @project.siteInScope?(chat.request.site) if @show_scope_only == true
+        if @show_scope_only == true
+           return false unless @project.siteInScope?(chat.request.site)
+        end 
         @tree_filters[:response_status].each do |rf|
         #puts "#{chat.response.status} / #{rf}"
-          add_chat = false if chat.response.status =~ /#{rf}/
+          return false if chat.response.status =~ /#{rf}/
         end
-
-        addChatItem(chat) if add_chat
+        addChatItem(chat)
       end
 
       # end