netzke-basepack 0.4.2 → 0.5.1

data/lib/netzke/masquerade_selector.rb

@@ -0,0 +1,53 @@
+module Netzke
+  class MasqueradeSelector < TabPanel
+    
+    def items
+      @items ||= [{
+          :name              => "roles",
+          :active            => true,
+          :widget_class_name => "GridPanel",
+          :data_class_name   => 'Role',
+          :columns           => [:id, :name],
+          :ext_config => {
+            :header        => false,
+            :bbar => ['search']
+          }
+        },{
+          :name                 => "users",
+          :preloaded            => true,
+          :widget_class_name    => "GridPanel", 
+          :data_class_name      => 'User', 
+          :ext_config           => {
+            :header        => false,
+            :rows_per_page => 10,
+            :bbar => ['search']
+          },
+          :columns => [:id, :login]
+      }]
+    end
+
+    def self.js_extend_properties
+      {
+        :after_constructor => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.items.each(function(tab){
+              tab.on('add', function(ct, cmp){
+                cmp.on('rowclick', this.rowclickHandler, this);
+              }, this);
+            }, this);
+          }
+        END_OF_JAVASCRIPT
+        
+        :rowclick_handler => <<-END_OF_JAVASCRIPT.l
+          function(grid, rowIndex, e){
+            var mode = grid.id.split("__").pop();
+            var normMode = mode === 'users' ? 'user' : 'role';
+            this.masquerade = {};
+            this.masquerade[normMode] = grid.store.getAt(rowIndex).get('id');
+          }
+        END_OF_JAVASCRIPT
+      }
+    end
+    
+  end
+end

data/lib/netzke/panel.rb

@@ -1,4 +1,13 @@
 module Netzke
   class Panel < Base
+    def self.js_extend_properties
+      {
+        :update_body_html => <<-END_OF_JAVASCRIPT.l,
+          function(html){
+            this.body.update(html);
+          }
+        END_OF_JAVASCRIPT
+      }
+    end
   end
 end

data/lib/netzke/plugins/configuration_tool.rb

@@ -0,0 +1,121 @@
+module Netzke::Plugins
+  # Include this module into any widget where you want a "gear" tool button in the top toolbar 
+  # which will triggger a modal window, which will load the ConfigurationPanel TabPanel-based 
+  # widget, which in its turn will contain all the aggregatees specified in widget's "configuration_widgets" 
+  # method (which *must* be defined)
+  module ConfigurationTool
+    def self.included(base)
+      base.extend ClassMethods
+      
+      base.class_eval do
+        # replacing instance methods
+        [:config, :initial_aggregatees, :js_config].each{ |m| alias_method_chain m, :config_tool }
+        
+        # replacing class methods
+        class << self
+          alias_method_chain :js_extend_properties, :config_tool
+        end
+
+        # API to commit the changes
+        api :commit
+      end
+
+      # if you include ConfigurationTool, you are supposed to provide configuration_widgets method which will returns an array of arrgeratees
+      # that will be included in the property window (each in its own tab or accordion pane)
+      raise "configuration_widgets method undefined" unless base.instance_methods.include?("configuration_widgets")
+    end
+
+    module ClassMethods
+      def js_extend_properties_with_config_tool
+        js_extend_properties_without_config_tool.merge({
+          :gear => <<-END_OF_JAVASCRIPT.l
+            function(){
+              var w = new Ext.Window({
+                title:'Config - '+ this.dataClassName,
+                layout:'fit',
+                modal:true,
+                width: Ext.lib.Dom.getViewWidth() *0.9,
+                height: Ext.lib.Dom.getViewHeight() *0.9,
+                closeAction:'destroy',
+                buttons:[{
+                  text:'OK',
+                  disabled: !this.configurable,
+                  tooltip: this.configurable ? null : "No dynamic configuration for this component",
+                  handler:function(){
+                    w.closeRes = 'OK'; 
+                    w.close();
+                  }
+                },{
+                  text:'Cancel',
+                  handler:function(){
+                    w.closeRes = 'cancel'; 
+                    w.close();
+                  }
+                }]
+
+              });
+
+              w.show(null, function(){
+                this.loadAggregatee({id:"configuration_panel", container:w.id});
+              }, this);
+
+              w.on('close', function(){
+                if (w.closeRes == 'OK'){
+                  var configurationPanel = this.getChildWidget('configuration_panel');
+                  var panels = configurationPanel.getLoadedChildren();
+                  var commitData = {};
+                  Ext.each(panels, function(p){
+                    if (p.getCommitData) {commitData[p.localId(configurationPanel)] = p.getCommitData();}
+                  }, this);
+                  configurationPanel.commit({commit_data:Ext.encode(commitData)});
+                }
+              }, this);
+            }
+          END_OF_JAVASCRIPT
+        })
+      end
+    end
+
+    def config_with_config_tool
+      orig_config = config_without_config_tool
+      return orig_config unless config_tool_needed?
+      orig_config.deep_merge({
+        :ext_config => {
+          :tools => orig_config[:ext_config][:tools].clone << "gear",
+          :header => true
+        }
+      })
+    end
+
+    def initial_aggregatees_with_config_tool
+      res = initial_aggregatees_without_config_tool
+      
+      # Add the ConfigurationPanel as aggregatee, which in its turn aggregates widgets from the 
+      # configuration_widgets method
+      res.merge!(:configuration_panel => {
+        :widget_class_name => 'ConfigurationPanel', 
+        :items => configuration_widgets,
+        :late_aggregation => true
+      }) if config_tool_needed?
+      
+      res
+    end
+
+    def tools_with_config_tool
+      tools = tools_without_config_tool
+      # Add the toolbutton
+      tools << 'gear' if config_tool_needed?
+      tools
+    end
+  
+    def js_config_with_config_tool
+      orig_config = js_config_without_config_tool
+      orig_config.merge(:configurable => config[:persistent_config])
+    end
+  
+    def config_tool_needed?
+      config_without_config_tool[:ext_config][:config_tool] || config_without_config_tool[:ext_config][:mode] == :config
+    end
+  
+  end
+end

data/lib/netzke/property_editor.rb

@@ -3,15 +3,103 @@ module Netzke
     
     def initialize(*args)
       super
-      PropertyEditorExtras::HelperModel.widget_name = config[:widget_name]
-      config[:data_class_name] = "Netzke::PropertyEditorExtras::HelperModel"
-      config[:record] = PropertyEditorExtras::HelperModel.new
-      config[:bbar] = %w{ apply }
-      config[:persistent_layout] = false
+      @widget = @passed_config[:widget]
+    end
+    
+    def independent_config
+      res = super
+      res[:ext_config][:bbar] = %w{ restore_defaults }
+      res
+    end
+
+    def actions
+      {:restore_defaults => {:text => "Restore defaults"}}
     end
 
-    def self.js_base_class
-      FormPanel
+    def get_columns
+      fields = @widget.class.property_fields
+
+      for f in fields
+        f[:value] = @widget.flat_config(f[:name]).nil? ? f[:default] : @widget.flat_config(f[:name])
+        f[:xtype] = XTYPE_MAP[f[:type]]
+        f[:field_label] = f[:name].to_s.gsub("__", "/").humanize
+      end
+      
+      fields
+    end
+    
+    def self.js_extend_properties
+      {
+        :label_width => 200,
+        
+        # Disable the 'gear' tool for now
+        :gear => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.feedback("You can't configure property editor (yet)");
+          }
+        END_OF_JAVASCRIPT
+        
+        :restore_defaults => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.restoreDefaults();
+          }
+        END_OF_JAVASCRIPT
+        
+        :get_commit_data => <<-END_OF_JAVASCRIPT.l
+          function(){
+            if (!this.getForm().isValid()) {this.getForm().reset()}; // if some fields are invalid, don't send anything
+            var values = this.getForm().getValues();
+            for (var k in values) {
+              if (values[k] == "") {values[k] = null}
+            }
+            return values;
+          }
+        END_OF_JAVASCRIPT
+      }
     end
+    
+    api :restore_defaults
+    def restore_defaults(params)
+      values = []
+      columns.each do |c|
+        init_config = @widget.flat_initial_config.detect{ |ic| ic[:name] == c[:name] }
+        
+        if init_config.nil?
+          property_fields ||= @widget.class.property_fields
+          values << property_fields.detect{ |f| f[:name] == c[:name] }[:default]
+        else
+          values << init_config[:value]
+        end
+        
+      end
+      {:set_form_values => values}
+    end
+    
+    def commit(data)
+      fields = @widget.class.property_fields
+      data.each_pair do |property, value|
+        field = fields.detect{ |f| f[:name] == property.to_sym }
+        # default = @widget.config[property].nil? ? field[:default] : @widget.config[property]
+        default = @widget.flat_initial_config(property).nil? ? field[:default] : @widget.flat_initial_config(property)
+        # Only store the value in persistent config when it's different from the default one
+        if field[:type] == :boolean
+          # handle boolean type separately
+          value = value.to_b
+          @widget.persistent_config[property] = value ^ default ? value : nil
+        else 
+          if field[:type] == :json
+            value = ActiveSupport::JSON.decode(value)
+          end
+
+          # Empty string means "null" for now...
+          # value = nil if value.blank?
+          # logger.debug "!!! value: #{value.inspect}\n"
+          
+          @widget.persistent_config[property] = default == value ? nil : value
+        end
+      end
+      {}
+    end
+    
   end
 end

data/lib/netzke/property_editor_extras/helper_model.rb

@@ -1,18 +1,27 @@
 module Netzke
   module PropertyEditorExtras 
     class HelperModel
-      def self.widget_name=(name)
-        @@widget_name = name
+      def self.widget=(w)
+        @@widget = w
       end
-  
-      def self.exposed_columns
-        # preferences = NetzkePreference.find_all_by_widget_name_and_user_id(@@widget_name, Netzke::Base.user && Netzke::Base.user.id)
-        preferences = NetzkePreference.find_all_for_widget(@@widget_name)
-        preferences.map{|p| {
-          :name => p.name,
-          :field_label => p.name.gsub('__', "/").humanize,
-          :type => p.pref_type.to_sym
-        }}
+      
+      def self.widget
+        @@widget ||= raise RuntimeError, "No widget specified for PropertyEditorExtras::HelperModel"
+      end
+      
+      def self.reflect_on_all_associations
+        []
+      end
+      
+      def self.primary_key
+        "id"
+      end
+      
+      def self.netzke_exposed_attributes
+        preferences = self.widget.flat_default_config
+        # preferences = NetzkePreference.find_all_for_widget(widget.name)
+        preferences.each { |p| p.reject!{ |k,v| k == :value}.merge!(:field_label => p[:name].to_s.gsub('__', "/").humanize) }
+        preferences
       end
 
       DEFAULTS_FOR_FIELD = {
@@ -57,7 +66,7 @@ module Netzke
         a
       end
   
-      def to_array(columns)
+      def to_array(columns, widget = nil)
         res = []
         for c in columns
           method = c.is_a?(Symbol) ? c : c[:name]
@@ -67,36 +76,48 @@ module Netzke
         res
       end
 
+      # somewhat sofisticated code to convert all NetzkePreferences for current widget into a hash ("un-flatten")
+      def attributes
+        prefs = NetzkePreference.find_all_for_widget(self.class.widget.id_name)
+        res = {}
+        prefs.each do |p|
+          tmp_res = {}
+          hsh_levels = p.name.split("__").map(&:to_sym)
+          hsh_levels.each do |level_prefix|
+            tmp_res[level_prefix] ||= level_prefix == hsh_levels.last ? p.normalized_value : {}
+            res[level_prefix] = tmp_res[level_prefix] if level_prefix == hsh_levels.first
+            tmp_res = tmp_res[level_prefix]
+          end
+        end
+        res
+      end
+
       def method_missing(method_name, *args)
+        # Rails.logger.debug "!!! method_name: #{method_name.inspect}"
         method_name = method_name.to_s
         method_name_without_equal_sign = method_name.sub(/=$/, '')
-        NetzkePreference.widget_name = @@widget_name
+        NetzkePreference.widget_name = self.class.widget.id_name
 
         if method_name =~ /=$/
-          current_value = NetzkePreference[method_name_without_equal_sign]
-          new_value = args.first
-      
-          if new_value.blank?
-            new_value = nil
-          else
-            if current_value.is_a?(Array) || current_value.is_a?(Hash)
-              begin
-                # JSON-parse if we expect an Array on Hash
-                new_value = ActiveSupport::JSON.decode(new_value)
-              rescue JSON::ParserError
-                new_value = current_value # TODO: provide nice feedback about JSON parsing failed
-              end
-            elsif current_value.is_a?(TrueClass) || current_value.is_a?(FalseClass)
-              # convert to true/false if expecting a Boolean
-              new_value = {"false" => false, "true" => true}[new_value] 
-            else
-              new_value = new_value.send(NetzkePreference::ELEMENTARY_CONVERTION_METHODS[current_value.class.name])
-            end
+          # current_value = NetzkePreference[method_name_without_equal_sign] # may be nil
+          current_value = self.class.widget.flat_independent_config(method_name_without_equal_sign)
+          
+          begin
+            new_value = ActiveSupport::JSON.decode(args.first) # TODO: provide feedback about this error
+          rescue ActiveSupport::JSON::ParseError
+            new_value = current_value
           end
-
+          
+          # default_value = self.class.widget.flat_default_config(method_name_without_equal_sign)
+          initial_value = self.class.widget.flat_initial_config(method_name_without_equal_sign)
+      
+          new_value = nil if new_value == initial_value
+          # Rails.logger.debug "!!! new_value: #{new_value.inspect}"
           NetzkePreference[method_name_without_equal_sign] = new_value
         else
-          NetzkePreference[method_name_without_equal_sign]
+          res = self.class.widget.flat_independent_config(method_name_without_equal_sign)
+          res = ActiveSupport::JSON.encode(res) if res.is_a?(Array) || res.is_a?(Hash)
+          res
         end
       end
   

data/lib/netzke/search_panel.rb

@@ -0,0 +1,62 @@
+module Netzke
+  # SearchPanel
+  # 
+  # FormPanel-based widget that allows create configurable searchlogic-compatible searches. 
+  # Pretty much work in progress.
+  class SearchPanel < FormPanel
+    # Something like [:equals, :greater_than_or_equal_to, :does_not_equal, :less_than, :less_than_or_equal_to, :greater_than, :ends_with, :like, :begins_with, :empty, :null]
+    CONDITIONS = [:COMPARISON_CONDITIONS, :WILDCARD_CONDITIONS, :BOOLEAN_CONDITIONS].inject([]){|r, c| r + Searchlogic::NamedScopes::Conditions.const_get(c).keys}
+    
+    def default_config
+      super.merge({
+        :data_class_name => @passed_config[:search_class_name]
+      })
+    end
+    
+    def default_columns
+      res = super
+
+      res.map! do |f| 
+        norm_column = normalize_column(f)
+        norm_column.merge!({
+          :condition => "equals"
+        })
+        norm_column.merge!(:hidden => true) if norm_column[:name].to_s.index("__")
+        
+        norm_column
+      end
+      
+      res
+    end
+    
+    # columns to be displayed by the FieldConfigurator (which is GridPanel-based)
+    def self.config_columns
+      [
+        {:name => :hidden, :type => :boolean, :editor => :checkbox, :width => 50},
+        {:name => :name, :type => :string, :editor => :combobox},
+        {:name => :condition, :type => :string, :editor => {:xtype => :combobox, :options => CONDITIONS}},
+        {:name => :field_label, :type => :string},
+        {:name => :xtype, :type => :string},
+        {:name => :value, :type => :string},
+      ]
+    end
+
+    # tweaking the form fields at the last moment
+    def js_config
+      super.merge({
+        :clmns => columns.map{ |c| c.merge({
+          :field_label => "#{c[:field_label] || c[:name]} #{c[:condition]}".humanize,
+          :name => "#{c[:name]}_#{c[:condition]}"
+        })}
+      })
+    end
+    
+    # we need to correct the queries to cut off the condition suffixes, otherwise the FormPanel gets confused
+    def get_combobox_options(params)
+      column_name = params[:column]
+      CONDITIONS.each { |c| column_name.sub!(/_#{c}$/, "") }
+      super(:column => column_name)
+    end
+    
+  end
+end